home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 1999 #2 / Amiga Plus CD - 1999 - No. 2.iso / Anwender / Office / AmigaWriter / Patches / AW1.02-GermanSpecial.lha / AmigaWriter-1st_Patch / Tools / source / StormScreenManager.cpp < prev    next >
C/C++ Source or Header  |  1998-09-23  |  75KB  |  2,679 lines
  1. /*
  2.  
  3. StormScreenManager (SSM) Version 2.0
  4.  
  5. */
  6.  
  7. #include "ScreenManager.h"
  8. #include <dos/dos.h>
  9. #include <exec/memory.h>
  10. #include <intuition/gadgetclass.h>
  11. #include <intuition/imageclass.h>
  12. #include <libraries/asl.h>
  13. #include <libraries/commodities.h>
  14. #include <libraries/wizard.h>
  15. #include <rexx/errors.h>
  16. #include <workbench/workbench.h>
  17.  
  18. #include <clib/alib_protos.h>
  19. #include <clib/asl_protos.h>
  20. #include <clib/commodities_protos.h>
  21. #include <clib/diskfont_protos.h>
  22. #include <clib/dos_protos.h>
  23. #include <clib/exec_protos.h>
  24. #include <clib/graphics_protos.h>
  25. #include <clib/icon_protos.h>
  26. #include <clib/intuition_protos.h>
  27. #include <clib/locale_protos.h>
  28. #include <clib/rexxsyslib_protos.h>
  29. #include <clib/utility_protos.h>
  30. #include <clib/wb_protos.h>
  31. #include <clib/wizard_protos.h>
  32.  
  33. #include <string.h>
  34. #include <stdio.h>
  35. #include <ctype.h>
  36.  
  37. #define WBSTART_LIKE_SAS
  38. #include <wbstartup.h>
  39.  
  40. #define CATCOMP_NUMBERS
  41. #define CATCOMP_STRINGS
  42. #include "ScreenManagerAll.h"
  43.  
  44. #define EVT_HOTKEY 1
  45.  
  46. struct Screen *GlbScreenP;     // Open SSM User Interface on this screen
  47. struct Catalog *GlbCatalogP;   // SSM User Interface catalog
  48. APTR GlbSurfaceP;              // Wizard Interface Descriptor
  49. struct MsgPort *GlbIDCMPortP;  // Shared IDCM Port for all windows
  50. LONG GlbScreenSignal;          // All public screens use the same signal
  51. BPTR GlbCurrentDir;            // Backup of current directory
  52. STRPTR GlbProgramNameP;        // Name of Program
  53. BOOL GlbExitSoonF;             // Exit as soon as every screen is closed
  54.  
  55. extern UBYTE WizardSurface[];  // Wizard resource is linked to executable
  56.  
  57. struct WindowGeometry
  58. {
  59.     BOOL Set;
  60.     LONG LeftEdge, TopEdge, Width, Height;
  61. };
  62.  
  63. // main window variables
  64. struct WindowGeometry GlbManagerWindowGeometry;
  65. struct WizardWindowHandle *GlbManagerWindowHandleP;
  66. struct NewWindow *GlbManagerNewWindowP;
  67. struct Window *GlbManagerWindowP;
  68. struct Gadget *GlbManagerGadgets[MANAGERWIN_ID_GADGETS];
  69.  
  70. // property window variables
  71. struct WindowGeometry GlbPropertiesWindowGeometry;
  72. struct WizardWindowHandle *GlbPropertiesWindowHandleP;
  73. struct NewWindow *GlbPropertiesNewWindowP;
  74. struct Window *GlbPropertiesWindowP;
  75. struct Gadget *GlbPropertiesGadgets[PROPERTIESWIN_ID_GADGETS];
  76. BOOL GlbOpenPropertiesF;
  77.  
  78. // asl font requester
  79. struct // loaded parameters
  80. {
  81.     BOOL Set;
  82.     ULONG Left, Top;
  83.     ULONG Width, Height;
  84. } GlbFontGeometry;
  85. struct FontRequester *GlbFontRequesterP;
  86.  
  87. // asl screen mode requester
  88. struct // loaded parameters
  89. {
  90.     BOOL Set;
  91.     ULONG Left, Top;
  92.     ULONG Width, Height;
  93.     BOOL InfoSet;
  94.     BOOL InfoOpened;              // InfoOpened, InfoWidth, InfoHeight are not
  95.     ULONG InfoLeft, InfoTop;      // supported to be set by AllocAslRequest()
  96.     ULONG InfoWidth, InfoHeight;  // so it is "future expansion"
  97. } GlbScreenModeGeometry;
  98. struct ScreenModeRequester *GlbScreenModeRequesterP;
  99.  
  100. // some global screen flags
  101. BOOL GlbShanghaiF;
  102. BOOL GlbAutoPopupF;
  103.  
  104. // commodity variables
  105. CxObj *GlbBrokerP;
  106. struct MsgPort *GlbBrokerPortP;
  107. BOOL GlbStartPopupF;
  108. LONG GlbCXPriority;
  109. BOOL GlbCXPopkeyF;
  110. UBYTE GlbCXPopkey[256];  // hot key description string
  111. BOOL GlbDisableF;
  112.  
  113. // rexx interface variables
  114. struct MsgPort *GlbRexxPortP;
  115. BOOL GlbRequestModeF;
  116.  
  117. // *************************************************************
  118. // ***
  119. // *** NAME      getlocalestr
  120. // *** FUNCTION  Simplify GetCatalogStr from locale.library
  121. // ***
  122. // *************************************************************
  123.  
  124. extern struct Library *LocaleBase;
  125.  
  126. STRPTR getlocalestr(ULONG id, STRPTR dflt)
  127. {
  128.     if (!LocaleBase)
  129.         return dflt;
  130.     return GetCatalogStr(GlbCatalogP,id,dflt);
  131. }
  132.  
  133. // *************************************************************
  134. // ***
  135. // *** NAME      ScreenNode
  136. // *** FUNCTION  Structure to store the screen parameters
  137. // ***
  138. // *************************************************************
  139.  
  140. struct ScreenNode
  141. {
  142.     struct WizardNode Node; // this is a node for wizard listviews
  143.     struct WizardNodeEntry Entries[6]; // 6 columns in my list
  144.     // work data
  145.     BOOL StormScreenF;   // TRUE : Screen is managed by StormScreenManager
  146.     BOOL OpenF;            // TRUE : Screen is currently open
  147.     BOOL CloseSoonF;     // TRUE : Close screen ASAP
  148.     BOOL OpenSoonF;      // TRUE : Open screen ASAP
  149.     struct Screen *Screen;      // pointer to screen, valid if OpenF == TRUE
  150.     struct Window *CloseGadget; // pointer to window showing the close gadget
  151.     STRPTR DefaultTitle;        // the old default title
  152.     // screen description
  153.     UBYTE Name[MAXPUBSCREENNAME]; // screen name
  154.     ULONG ModeID;          // display mode id
  155.     ULONG Depth;
  156.     ULONG Height;
  157.     ULONG Width;
  158.     UWORD Overscan;        // OSCAN_#?
  159.     BOOL AutoScrollF;
  160.     struct TextAttr Font;
  161.     BOOL OpenBehindF;
  162.     // more properties
  163.     BOOL CloseGadgetF;     // make a close gadget for this screen
  164.     BOOL QuietF;
  165.     UBYTE Title[256]; // if (strlen(Title) == 0) use pubscreen name
  166.     ULONG SysFont;    // 0 = custom font, 1 = system font, 2 = workbench font
  167.     UWORD Pens[15];   // currently not configurable, Pens[0] == ~0
  168.     BOOL LikeWorkbenchF;
  169.     BOOL DraggableF;
  170.     BOOL ExclusiveF;
  171.     struct            // colors are currently not configurable
  172.     {
  173.         struct loadrgb;
  174.         ULONG colors[3*256];
  175.     } colors32;
  176.     // buffers for listview texts
  177.     UBYTE ModeName[DISPLAYNAMELEN];
  178.     UBYTE FontText[64];
  179.     // more buffers
  180.     UBYTE FontName[64];     // Font.ta_Name points to this array
  181.     UBYTE ScreenTitle[280]; // the actual screen title is stored here
  182. };
  183.  
  184. struct MinList ScreenList;
  185. struct ScreenNode HeaderNode;    // the header node for the listview
  186. struct ScreenNode *ActiveNodeP;  // actual selected node
  187. struct ScreenNode *DefaultScreenNodeP; // this screen is the default screen
  188.  
  189. // *************************************************************
  190. // ***
  191. // *** NAME      AllocScreenNode
  192. // *** FUNCTION  Allocates a new ScreenNode entry and initializes it
  193. // ***
  194. // *************************************************************
  195. struct ScreenNode *AllocScreenNode(STRPTR Name)
  196. {
  197.     struct ScreenNode *node = (struct ScreenNode *) AllocVec(sizeof(struct ScreenNode),MEMF_CLEAR);
  198.     if (node)
  199.     {
  200.         strcpy(node->Name,Name);
  201.         node->CloseGadgetF = TRUE;
  202.         node->Pens[0] = ~0;
  203.         WZ_InitNode(&node->Node,6,       // 6 columns
  204.             TAG_END);
  205.         WZ_InitNodeEntry(&node->Node,0,  // Initialize each column
  206.             WENTRYA_Type,WNE_TEXT,
  207.             WENTRYA_TextPen,WZRD_TEXTPEN,
  208.             WENTRYA_TextSPen,WZRD_TEXTPEN,
  209.             WENTRYA_TextString,"",
  210.             TAG_END);
  211.         WZ_InitNodeEntry(&node->Node,1,
  212.             WENTRYA_Type,WNE_TEXT,
  213.             WENTRYA_TextPen,WZRD_TEXTPEN,
  214.             WENTRYA_TextSPen,WZRD_TEXTPEN,
  215.             WENTRYA_TextString,&node->Name,
  216.             TAG_END);
  217.         WZ_InitNodeEntry(&node->Node,2,
  218.             WENTRYA_Type,WNE_VIMAGE,
  219.             WENTRYA_VImageType,10,
  220.             TAG_END);
  221.         WZ_InitNodeEntry(&node->Node,3,
  222.             WENTRYA_Type,WNE_TEXT,
  223.             WENTRYA_TextPen,WZRD_TEXTPEN,
  224.             WENTRYA_TextSPen,WZRD_TEXTPEN,
  225.             WENTRYA_TextString,"",
  226.             TAG_END);
  227.         WZ_InitNodeEntry(&node->Node,4,
  228.             WENTRYA_Type,WNE_VIMAGE,
  229.             WENTRYA_VImageType,10,
  230.             TAG_END);
  231.         WZ_InitNodeEntry(&node->Node,5,
  232.             WENTRYA_Type,WNE_TEXT,
  233.             WENTRYA_TextPen,WZRD_TEXTPEN,
  234.             WENTRYA_TextSPen,WZRD_TEXTPEN,
  235.             WENTRYA_TextString,"",
  236.             TAG_END);
  237.     }
  238.     return node;
  239. }
  240.  
  241. // *************************************************************
  242. // ***
  243. // *** NAME      FreeScreenNode
  244. // *** FUNCTION  frees a screen node and release allocated resources
  245. // ***           (currently none)
  246. // ***
  247. // *************************************************************
  248. void FreeScreenNode(struct ScreenNode *node)
  249. {
  250.     FreeVec(node);
  251. }
  252.  
  253. // *************************************************************
  254. // ***
  255. // *** NAME      FreeScreenList
  256. // *** FUNCTION  remove and free all ScreenNodes from the global list
  257. // ***
  258. // *************************************************************
  259. void FreeScreenList()
  260. {
  261.     struct ScreenNode *node;
  262.     while (node = (struct ScreenNode *) RemHead((struct List *) &ScreenList))
  263.         FreeScreenNode(node);
  264. }
  265.  
  266. // *************************************************************
  267. // ***
  268. // *** NAME      InitHeaderNode
  269. // *** FUNCTION  Initialize the header node used for the listview
  270. // ***
  271. // *************************************************************
  272. void InitHeaderNode()
  273. {
  274.     struct ScreenNode *node = &HeaderNode;
  275.     WZ_InitNode(&node->Node,6,      // 6 columns
  276.         TAG_END);
  277.     WZ_InitNodeEntry(&node->Node,0, // initialize each column
  278.         WENTRYA_Type,WNE_TEXT,
  279.         WENTRYA_TextPen,WZRD_TEXTPEN,
  280.         WENTRYA_TextSPen,WZRD_TEXTPEN,
  281.         WENTRYA_TextStyle,FSF_BOLD,
  282.         WENTRYA_TextString,"·",
  283.         TAG_END);
  284.     WZ_InitNodeEntry(&node->Node,1,
  285.         WENTRYA_Type,WNE_TEXT,
  286.         WENTRYA_TextPen,WZRD_TEXTPEN,
  287.         WENTRYA_TextSPen,WZRD_TEXTPEN,
  288.         WENTRYA_TextStyle,FSF_BOLD,
  289.         WENTRYA_TextString,getlocalestr(MSG_NAME_ID,MSG_NAME_ID_STR),
  290.         TAG_END);
  291.     WZ_InitNodeEntry(&node->Node,2, // this feature is new for the latest
  292.         WENTRYA_Type,WNE_VIMAGE,     // wizard.library. If you have not the
  293.         WENTRYA_VImageType,10,       // newest version you will not see the
  294.         TAG_END);                    // vertical bars
  295.     WZ_InitNodeEntry(&node->Node,3,
  296.         WENTRYA_Type,WNE_TEXT,
  297.         WENTRYA_TextPen,WZRD_TEXTPEN,
  298.         WENTRYA_TextSPen,WZRD_TEXTPEN,
  299.         WENTRYA_TextStyle,FSF_BOLD,
  300.         WENTRYA_TextString,getlocalestr(MSG_DISPLAYMODE_ID,MSG_DISPLAYMODE_ID_STR),
  301.         TAG_END);
  302.     WZ_InitNodeEntry(&node->Node,4,
  303.         WENTRYA_Type,WNE_VIMAGE,
  304.         WENTRYA_VImageType,10,
  305.         TAG_END);
  306.     WZ_InitNodeEntry(&node->Node,5,
  307.         WENTRYA_Type,WNE_TEXT,
  308.         WENTRYA_TextPen,WZRD_TEXTPEN,
  309.         WENTRYA_TextSPen,WZRD_TEXTPEN,
  310.         WENTRYA_TextStyle,FSF_BOLD,
  311.         WENTRYA_TextString,getlocalestr(MSG_FONT_ID,MSG_FONT_ID_STR),
  312.         TAG_END);
  313. }
  314.  
  315. // *************************************************************
  316. // ***
  317. // *** NAME      SetScreenName
  318. // *** FUNCTION  Set the screen name for the given node
  319. // ***
  320. // *************************************************************
  321. void SetScreenName(struct ScreenNode *node, STRPTR Name)
  322. {
  323.     strcpy(node->Name,Name);
  324.     WZ_InitNodeEntry(&node->Node,1,
  325.         WENTRYA_TextString,&node->Name,
  326.         TAG_END);
  327. }
  328.  
  329. // *************************************************************
  330. // ***
  331. // *** NAME      SetScreenMode
  332. // *** FUNCTION  Set display mode and some values from the asl requester
  333. // ***
  334. // *************************************************************
  335. void SetScreenMode(struct ScreenNode *node, ULONG modeid,
  336.     ULONG depth, ULONG height, ULONG width, UWORD overscan, BOOL autoscroll)
  337. {
  338.     struct NameInfo nameinfo;
  339.     if (GetDisplayInfoData(NULL,(UBYTE *) &nameinfo,sizeof(struct NameInfo),DTAG_NAME,modeid))
  340.     {
  341.         strcpy(node->ModeName,nameinfo.Name);
  342.         WZ_InitNodeEntry(&node->Node,3,
  343.             WENTRYA_TextString,&node->ModeName,
  344.             TAG_END);
  345.     }
  346.     else
  347.     {
  348.         WZ_InitNodeEntry(&node->Node,3,
  349.             WENTRYA_TextString,getlocalestr(MSG_UNKNOWN_ID,MSG_UNKNOWN_ID_STR),
  350.             TAG_END);
  351.     }
  352.     node->ModeID = modeid;
  353.     node->Depth = depth;
  354.     node->Height = height;
  355.     node->Width = width;
  356.     node->Overscan = overscan;
  357.     node->AutoScrollF = autoscroll;
  358. }
  359.  
  360. // *************************************************************
  361. // ***
  362. // *** NAME      SetScreenFont
  363. // *** FUNCTION  Set the screen font from the asl requester
  364. // ***
  365. // *************************************************************
  366. void SetScreenFont(struct ScreenNode *node, struct TextAttr *tattr)
  367. {
  368.     sprintf(node->FontText,getlocalestr(MSG_FONTTEXT_ID,MSG_FONTTEXT_ID_STR),
  369.         tattr->ta_Name,tattr->ta_YSize);
  370.     WZ_InitNodeEntry(&node->Node,5,
  371.         WENTRYA_TextString,&node->FontText,
  372.         TAG_END);
  373.     strcpy(node->FontName,tattr->ta_Name);
  374.     node->Font = *tattr;
  375.     node->Font.ta_Name = node->FontName;
  376.     node->Font.ta_Style &= ~FSF_TAGGED; // for safety
  377. }
  378.  
  379. // *************************************************************
  380. // ***
  381. // *** NAME      AddScreenNode
  382. // *** FUNCTION  Add node to list, alphanumerical sorted
  383. // ***
  384. // *************************************************************
  385. void AddScreenNode(struct ScreenNode *node)
  386. {
  387.     struct ScreenNode *n;
  388.     for (n = (struct ScreenNode *) ScreenList.mlh_Head;
  389.         n->Node.Node.mln_Succ;
  390.         n = (struct ScreenNode *) n->Node.Node.mln_Succ)
  391.     {
  392.         if (Stricmp(n->Name,node->Name) > 0)
  393.         {
  394.             Insert((struct List *) &ScreenList, (struct Node *) &node->Node.Node,
  395.                 (struct Node *) n->Node.Node.mln_Pred);
  396.             return;
  397.         }
  398.     }
  399.     AddTail((struct List *) &ScreenList, (struct Node *) &node->Node.Node);
  400. }
  401.  
  402. // *************************************************************
  403. // ***
  404. // *** NAME      RemScreenNode
  405. // *** FUNCTION  Remove a screen node from its list
  406. // ***
  407. // *************************************************************
  408. void RemScreenNode(struct ScreenNode *node)
  409. {
  410.     Remove((struct Node *) &node->Node.Node);
  411. }
  412.  
  413. // *************************************************************
  414. // ***
  415. // *** NAME      FindScreenNode
  416. // *** FUNCTION  Find a screen node with the given name
  417. // ***
  418. // *************************************************************
  419. struct ScreenNode *FindScreenNode(STRPTR Name)
  420. {
  421.     struct ScreenNode *node;
  422.     for (node = (struct ScreenNode *) ScreenList.mlh_Head;
  423.         node->Node.Node.mln_Succ;
  424.         node = (struct ScreenNode *) node->Node.Node.mln_Succ)
  425.     {
  426.         if (Stricmp(node->Name,Name) == 0)
  427.             return node;
  428.     }
  429.     return NULL;
  430. }
  431.  
  432. // *************************************************************
  433. // ***
  434. // *** NAME      GetScreenNode
  435. // *** FUNCTION  Find a screen node with the given index
  436. // ***
  437. // *************************************************************
  438. struct ScreenNode *GetScreenNode(ULONG index)
  439. {
  440.     ULONG i = 0;
  441.     struct ScreenNode *node;
  442.     for (node = (struct ScreenNode *) ScreenList.mlh_Head;
  443.         node->Node.Node.mln_Succ;
  444.         node = (struct ScreenNode *) node->Node.Node.mln_Succ)
  445.     {
  446.         if (index == i)
  447.             return node;
  448.         i++;
  449.     }
  450.     return NULL;
  451. }
  452.  
  453. // *************************************************************
  454. // ***
  455. // *** NAME      GetScreenNodeIndex
  456. // *** FUNCTION  Count the index for a given screen node
  457. // ***
  458. // *************************************************************
  459. ULONG GetScreenNodeIndex(struct ScreenNode *n)
  460. {
  461.     ULONG i = 0;
  462.     struct ScreenNode *node;
  463.     for (node = (struct ScreenNode *) ScreenList.mlh_Head;
  464.         node->Node.Node.mln_Succ;
  465.         node = (struct ScreenNode *) node->Node.Node.mln_Succ)
  466.     {
  467.         if (node == n)
  468.             return i;
  469.         i++;
  470.     }
  471.     return ~0;
  472. }
  473.  
  474. // *************************************************************
  475. // ***
  476. // *** NAME      LengthOfScreenList
  477. // *** FUNCTION  Calculate the number of ScreenNodes in the list
  478. // ***
  479. // *************************************************************
  480. ULONG LengthOfScreenList()
  481. {
  482.     ULONG i = 0;
  483.     struct ScreenNode *node;
  484.     for (node = (struct ScreenNode *) ScreenList.mlh_Head;
  485.         node->Node.Node.mln_Succ;
  486.         node = (struct ScreenNode *) node->Node.Node.mln_Succ)
  487.     {
  488.         i++;
  489.     }
  490.     return i;
  491. }
  492.  
  493. // *************************************************************
  494. // ***
  495. // *** NAME      ScanOpenPubScreens
  496. // *** FUNCTION  Scan the list of public screens and add to list
  497. // ***
  498. // *************************************************************
  499. void ScanOpenPubScreens()
  500. {
  501.     struct ScreenNode *node, *succ;
  502.     for (node = (struct ScreenNode *) ScreenList.mlh_Head;
  503.         succ = (struct ScreenNode *) node->Node.Node.mln_Succ;
  504.         node = succ)
  505.     {
  506.         if (!node->StormScreenF)
  507.         {
  508.             RemScreenNode(node);
  509.             FreeScreenNode(node);
  510.         }
  511.     }
  512.     struct List *pubscreens = LockPubScreenList();
  513.     struct PubScreenNode *snode;
  514.     for (snode = (struct PubScreenNode *) pubscreens->lh_Head;
  515.         snode->psn_Node.ln_Succ;
  516.         snode = (struct PubScreenNode *) snode->psn_Node.ln_Succ)
  517.     {
  518.         if ((snode->psn_Flags & PSNF_PRIVATE) == 0)
  519.         {
  520.             if (!FindScreenNode(snode->psn_Node.ln_Name))
  521.             {
  522.                 struct ScreenNode *n = AllocScreenNode(snode->psn_Node.ln_Name);
  523.                 if (n)
  524.                 {
  525.                     AddScreenNode(n);
  526.                     n->OpenF = TRUE;
  527.                 }
  528.             }
  529.         }
  530.     }
  531.     UnlockPubScreenList()
  532. }
  533.  
  534. // *************************************************************
  535. // ***
  536. // *** NAME      SetDefaultScreenNode
  537. // *** FUNCTION  Make the given screen node the default public screen
  538. // ***
  539. // *************************************************************
  540. void SetDefaultScreenNode(struct ScreenNode *node)
  541. {
  542.     if (GlbManagerWindowHandleP)
  543.     {
  544.         SetGadgetAttrs(GlbManagerGadgets[GAD_MAN_LIST_ID],NULL,NULL,
  545.             WLISTVIEWA_List,NULL,
  546.             TAG_END);
  547.     }
  548.     if (node->OpenF)
  549.     {
  550.         if (DefaultScreenNodeP)
  551.         {
  552.             WZ_InitNodeEntry(&DefaultScreenNodeP->Node,0,
  553.                 WENTRYA_TextString,"",
  554.                 TAG_END);
  555.             DefaultScreenNodeP = NULL;
  556.         }
  557.         DefaultScreenNodeP = node;
  558.         SetDefaultPubScreen(node->Name);
  559.         WZ_InitNodeEntry(&DefaultScreenNodeP->Node,0,
  560.             WENTRYA_TextString,"·",
  561.             TAG_END);
  562.     }
  563.     if (GlbManagerWindowHandleP)
  564.     {
  565.         SetGadgetAttrs(GlbManagerGadgets[GAD_MAN_LIST_ID],GlbManagerWindowP,NULL,
  566.             WLISTVIEWA_List,&ScreenList,
  567.             TAG_END);
  568.     }
  569. }
  570.  
  571. // *************************************************************
  572. // ***
  573. // *** NAME      GetDefaultScreenNode
  574. // *** FUNCTION  Get the default public screen and reset it in the list
  575. // ***
  576. // *************************************************************
  577. struct ScreenNode *GetDefaultScreenNode()
  578. {
  579.     UBYTE Name[MAXPUBSCREENNAME];
  580.     GetDefaultPubScreen(Name);
  581.     struct ScreenNode *node = FindScreenNode(Name);
  582.     if (node)
  583.         SetDefaultScreenNode(node);
  584.     return node;
  585. }
  586.  
  587. // *************************************************************
  588. // ***
  589. // *** NAME      IsAnyScreenOpen
  590. // *** FUNCTION  Returns TRUE if any screen is opened by SSM
  591. // ***
  592. // *************************************************************
  593. BOOL IsAnyScreenOpen()
  594. {
  595.     struct ScreenNode *node;
  596.     for (node = (struct ScreenNode *) ScreenList.mlh_Head;
  597.         node->Node.Node.mln_Succ;
  598.         node = (struct ScreenNode *) node->Node.Node.mln_Succ)
  599.     {
  600.         if (node->StormScreenF && node->OpenF)
  601.             return TRUE;
  602.     }
  603.     return FALSE;
  604. }
  605.  
  606. // *************************************************************
  607. // ***
  608. // *** NAME      Save
  609. // *** FUNCTION  Save the screen list and interface parameters to
  610. // ***           a workbench icon
  611. // ***
  612. // *************************************************************
  613. STRPTR Save(STRPTR Name)
  614. {
  615.     struct DiskObject *diskobj;
  616.     STRPTR ToolTypes[64];
  617.     UBYTE *Buffer;
  618.     if (!(Buffer = (UBYTE *) AllocVec(16384,MEMF_CLEAR)))
  619.         return getlocalestr(MSG_OUT_OF_MEMORY_ID,MSG_OUT_OF_MEMORY_ID_STR);
  620.     if (diskobj = GetDiskObject(Name))
  621.     {
  622.     }
  623.     else if (diskobj = GetDefDiskObject(WBTOOL))
  624.     {
  625.         diskobj->do_CurrentX = NO_ICON_POSITION;
  626.         diskobj->do_CurrentY = NO_ICON_POSITION;
  627.     }
  628.     else
  629.     {
  630.         FreeVec(Buffer);
  631.         return getlocalestr(MSG_UNABLE_TO_READ_ICON_ID,MSG_UNABLE_TO_READ_ICON_ID_STR);
  632.     }
  633.     // copy some tooltypes that are not configurable by SSM
  634.     STRPTR cxpriority = FindToolType((UBYTE **) diskobj->do_ToolTypes,"CX_PRIORITY");
  635.     STRPTR cxpopup = FindToolType((UBYTE **) diskobj->do_ToolTypes,"CX_POPUP");
  636.     if (!cxpopup)
  637.         cxpopup = "NO";
  638.     STRPTR cxpopkey = FindToolType((UBYTE **) diskobj->do_ToolTypes,"CX_POPKEY");
  639.     if (!cxpopkey)
  640.         cxpopkey = "control alt p";
  641.  
  642.     // set the standard tooltypes
  643.     ULONG i = 0;
  644.     STRPTR Buf = Buffer;
  645.     Buf += sprintf(ToolTypes[i++] = Buf,"DONOTWAIT") + 1;
  646.     if (cxpriority)
  647.         Buf += sprintf(ToolTypes[i++] = Buf,"CX_PRIORITY=%s",cxpriority) + 1;
  648.     Buf += sprintf(ToolTypes[i++] = Buf,"CX_POPUP=%s",cxpopup) + 1;
  649.     Buf += sprintf(ToolTypes[i++] = Buf,"CX_POPKEY=%s",cxpopkey) + 1;
  650.  
  651.     // save the global parameters
  652.     Buf += sprintf(ToolTypes[i++] = Buf,"SHANGHAI=%s",GlbShanghaiF ? "ON" : "OFF") + 1;
  653.     Buf += sprintf(ToolTypes[i++] = Buf,"AUTOPOPUP=%s",GlbAutoPopupF ? "ON" : "OFF") + 1;
  654.     if (DefaultScreenNodeP)
  655.         Buf += sprintf(ToolTypes[i++] = Buf,"DEFAULTSCREEN=%s",DefaultScreenNodeP->Name) + 1;
  656.  
  657.     // save the screen list
  658.     struct ScreenNode *node;
  659.     for (node = (struct ScreenNode *) ScreenList.mlh_Head;
  660.         node->Node.Node.mln_Succ;
  661.         node = (struct ScreenNode *) node->Node.Node.mln_Succ)
  662.     {
  663.         if (node->StormScreenF)
  664.         {
  665.             Buf += sprintf(ToolTypes[i++] = Buf,
  666.                 "SCREEN=%s/%ld/%ld/%ld/0x%lx/%s/%ld/%s/%ld/%ld/%ld/%ld/%ld/%s/%ld/%ld/%ld/%ld",
  667.                 node->Name,
  668.                 node->Width,
  669.                 node->Height,
  670.                 node->Depth,
  671.                 node->ModeID,
  672.                 node->Font.ta_Name,
  673.                 node->Font.ta_YSize,
  674.                 node->OpenF ? "on" : "off",
  675.                 node->OpenBehindF,
  676.                 node->CloseGadgetF,
  677.                 node->AutoScrollF,
  678.                 node->Overscan,
  679.                 node->QuietF,
  680.                 node->Title,
  681.                 node->SysFont,
  682.                 node->LikeWorkbenchF,
  683.                 node->DraggableF,
  684.                 node->ExclusiveF
  685.                 ) + 1;
  686.         }
  687.     }
  688.  
  689.     // save the interface parameters like window geometry etc
  690.     if (GlbManagerWindowP)
  691.     {
  692.         Buf += sprintf(ToolTypes[i++] = Buf,"WINDOW=%ld/%ld/%ld/%ld",
  693.             GlbManagerWindowP->LeftEdge,
  694.             GlbManagerWindowP->TopEdge,
  695.             GlbManagerWindowP->Width,
  696.             GlbManagerWindowP->Height) + 1;
  697.     }
  698.     else if (GlbManagerWindowGeometry.Set)
  699.     {
  700.         Buf += sprintf(ToolTypes[i++] = Buf,"WINDOW=%ld/%ld/%ld/%ld",
  701.             GlbManagerWindowGeometry.LeftEdge,
  702.             GlbManagerWindowGeometry.TopEdge,
  703.             GlbManagerWindowGeometry.Width,
  704.             GlbManagerWindowGeometry.Height) + 1;
  705.     }
  706.     if (GlbPropertiesWindowP)
  707.     {
  708.         Buf += sprintf(ToolTypes[i++] = Buf,"PROPERTIES=%ld/%ld/%ld/%ld/on",
  709.             GlbPropertiesWindowP->LeftEdge,
  710.             GlbPropertiesWindowP->TopEdge,
  711.             GlbPropertiesWindowP->Width,
  712.             GlbPropertiesWindowP->Height) + 1;
  713.     }
  714.     else if (GlbPropertiesWindowGeometry.Set)
  715.     {
  716.         Buf += sprintf(ToolTypes[i++] = Buf,"PROPERTIES=%ld/%ld/%ld/%ld/off",
  717.             GlbPropertiesWindowGeometry.LeftEdge,
  718.             GlbPropertiesWindowGeometry.TopEdge,
  719.             GlbPropertiesWindowGeometry.Width,
  720.             GlbPropertiesWindowGeometry.Height) + 1;
  721.     }
  722.     if (GlbScreenModeRequesterP)
  723.     {
  724.         Buf += sprintf(ToolTypes[i++] = Buf,"SCREENMODEREQ=%ld/%ld/%ld/%ld",
  725.             GlbScreenModeRequesterP->sm_LeftEdge,
  726.             GlbScreenModeRequesterP->sm_TopEdge,
  727.             GlbScreenModeRequesterP->sm_Width,
  728.             GlbScreenModeRequesterP->sm_Height) + 1;
  729.         Buf += sprintf(ToolTypes[i++] = Buf,"SCREENMODEINFO=%ld/%ld/%ld/%ld/%ld",
  730.             GlbScreenModeRequesterP->sm_InfoLeftEdge,
  731.             GlbScreenModeRequesterP->sm_InfoTopEdge,
  732.             GlbScreenModeRequesterP->sm_InfoWidth,
  733.             GlbScreenModeRequesterP->sm_InfoHeight,
  734.             GlbScreenModeRequesterP->sm_InfoOpened) + 1;
  735.     }
  736.     else if (GlbScreenModeGeometry.Set)
  737.     {
  738.         Buf += sprintf(ToolTypes[i++] = Buf,"SCREENMODEREQ=%ld/%ld/%ld/%ld",
  739.             GlbScreenModeGeometry.Left,
  740.             GlbScreenModeGeometry.Top,
  741.             GlbScreenModeGeometry.Width,
  742.             GlbScreenModeGeometry.Height) + 1;
  743.         if (GlbScreenModeGeometry.InfoSet)
  744.         {
  745.             Buf += sprintf(ToolTypes[i++] = Buf,"SCREENMODEINFO=%ld/%ld/%ld/%ld/%ld",
  746.                 GlbScreenModeGeometry.InfoLeft,
  747.                 GlbScreenModeGeometry.InfoTop,
  748.                 GlbScreenModeGeometry.InfoWidth,
  749.                 GlbScreenModeGeometry.InfoHeight,
  750.                 GlbScreenModeGeometry.InfoOpened) + 1;
  751.         }
  752.     }
  753.     if (GlbFontRequesterP)
  754.     {
  755.         Buf += sprintf(ToolTypes[i++] = Buf,"FONTREQ=%ld/%ld/%ld/%ld",
  756.             GlbFontRequesterP->fo_LeftEdge,
  757.             GlbFontRequesterP->fo_TopEdge,
  758.             GlbFontRequesterP->fo_Width,
  759.             GlbFontRequesterP->fo_Height) + 1;
  760.     }
  761.     else if (GlbFontGeometry.Set)
  762.     {
  763.         Buf += sprintf(ToolTypes[i++] = Buf,"FONTREQ=%ld/%ld/%ld/%ld",
  764.             GlbFontGeometry.Left,
  765.             GlbFontGeometry.Top,
  766.             GlbFontGeometry.Width,
  767.             GlbFontGeometry.Height) + 1;
  768.     }
  769.     ToolTypes[i] = NULL;
  770.  
  771.     // write icon to file
  772.     STRPTR *tooltypes = diskobj->do_ToolTypes;
  773.     diskobj->do_ToolTypes = ToolTypes;
  774.     if (!PutDiskObject(Name,diskobj))
  775.     {
  776.         diskobj->do_ToolTypes = tooltypes;
  777.         FreeDiskObject(diskobj);
  778.         FreeVec(Buffer);
  779.         return getlocalestr(MSG_UNABLE_TO_WRITE_ICON_ID,MSG_UNABLE_TO_WRITE_ICON_ID_STR);
  780.     }
  781.     diskobj->do_ToolTypes = tooltypes;
  782.     FreeDiskObject(diskobj);
  783.     FreeVec(Buffer);
  784.     return NULL; // no error string
  785. }
  786.  
  787. // *************************************************************
  788. // ***
  789. // *** NAME      Load
  790. // *** FUNCTION  Load a screen list and many parameters from a wb icon
  791. // ***
  792. // *************************************************************
  793. STRPTR Load(STRPTR Name)
  794. {
  795.     struct DiskObject *diskobj;
  796.     if (!(diskobj = GetDiskObject(Name)))
  797.         return NULL;
  798.     STRPTR v;
  799.  
  800.     // load some standard parameters
  801.     v = FindToolType((UBYTE **) diskobj->do_ToolTypes,"CX_PRIORITY");
  802.     if (v)
  803.     {
  804.         sscanf(v,"%ld",&GlbCXPriority);
  805.         if (GlbCXPriority > 127)
  806.             GlbCXPriority = 127;
  807.         else if (GlbCXPriority < -128)
  808.             GlbCXPriority = -128;
  809.     }
  810.     v = FindToolType((UBYTE **) diskobj->do_ToolTypes,"CX_POPUP");
  811.     if (v && (MatchToolValue(v,"ON") || MatchToolValue(v,"TRUE") || strlen(v) == 0))
  812.         GlbStartPopupF = TRUE;
  813.     v = FindToolType((UBYTE **) diskobj->do_ToolTypes,"CX_POPKEY");
  814.     if (v)
  815.     {
  816.         GlbCXPopkeyF = TRUE;
  817.         strcpy(GlbCXPopkey,v);
  818.     }
  819.  
  820.     // load some global variables
  821.     v = FindToolType((UBYTE **) diskobj->do_ToolTypes,"SHANGHAI");
  822.     if (v && (MatchToolValue(v,"ON") || MatchToolValue(v,"TRUE") || strlen(v) == 0))
  823.         GlbShanghaiF = TRUE;
  824.     v = FindToolType((UBYTE **) diskobj->do_ToolTypes,"AUTOPOPUP");
  825.     if (v && (MatchToolValue(v,"ON") || MatchToolValue(v,"TRUE") || strlen(v) == 0))
  826.         GlbAutoPopupF = TRUE;
  827.  
  828.     // build the screen list
  829.     STRPTR *ToolTypes = diskobj->do_ToolTypes;
  830.     while (*ToolTypes)
  831.     {
  832.         STRPTR ToolType = *ToolTypes;
  833.         UBYTE Name[MAXPUBSCREENNAME];
  834.         ULONG Width, Height, Depth, ModeID;
  835.         struct TextAttr Font = { };
  836.         UBYTE FontName[64];
  837.         UBYTE OpenF[6];
  838.         ULONG OpenBehindF = FALSE, CloseGadgetF = FALSE, AutoScrollF = FALSE;
  839.         ULONG Overscan = OSCAN_TEXT, QuietF = FALSE;
  840.         UBYTE Title[256] = { };
  841.         ULONG SysFont = 0, LikeWorkbenchF = FALSE, DraggableF = FALSE;
  842.         ULONG ExclusiveF = FALSE;
  843.         LONG parameters;
  844.         if (parameters = sscanf(ToolType,
  845.             "SCREEN=%[^/]/%ld/%ld/%ld/%lx/%[^/]/%hd/%[^/]/%ld/%ld/%ld/%ld/%ld/%[^/]/%ld/%ld/%ld/%ld",
  846.             Name,
  847.             &Width,
  848.             &Height,
  849.             &Depth,
  850.             &ModeID,
  851.             FontName,
  852.             &Font.ta_YSize,
  853.             OpenF,
  854.             &OpenBehindF,
  855.             &CloseGadgetF,
  856.             &AutoScrollF,
  857.             &Overscan,
  858.             &QuietF,
  859.             Title,
  860.             &SysFont,
  861.             &LikeWorkbenchF,
  862.             &DraggableF,
  863.             &ExclusiveF
  864.             ) >= 8)
  865.         {
  866.             struct ScreenNode *node;
  867.             if (node = AllocScreenNode(Name))
  868.             {
  869.                 node->StormScreenF = TRUE;
  870.                 SetScreenMode(node,ModeID,Depth,Height,Width,OSCAN_TEXT,TRUE);
  871.                 Font.ta_Name = FontName;
  872.                 SetScreenFont(node,&Font);
  873.                 node->OpenSoonF = (Stricmp(OpenF,"on") == 0); // screens will be opened later
  874.                 node->OpenBehindF = OpenBehindF;
  875.                 node->CloseGadgetF = CloseGadgetF;
  876.                 node->AutoScrollF = AutoScrollF;
  877.                 node->Overscan = Overscan;
  878.                 node->QuietF = QuietF;
  879.                 strcpy(node->Title,Title);
  880.                 node->SysFont = SysFont;
  881.                 node->LikeWorkbenchF = LikeWorkbenchF;
  882.                 node->DraggableF = DraggableF;
  883.                 node->ExclusiveF = ExclusiveF;
  884.                 AddScreenNode(node);
  885.             }
  886.             else
  887.             {
  888.                 FreeDiskObject(diskobj);
  889.                 return getlocalestr(MSG_OUT_OF_MEMORY_ID,MSG_OUT_OF_MEMORY_ID_STR);
  890.             }
  891.         }
  892.         ToolTypes++
  893.     }
  894.     v = FindToolType((UBYTE **) diskobj->do_ToolTypes,"DEFAULTSCREEN");
  895.     if (v)
  896.     {
  897.         DefaultScreenNodeP = FindScreenNode(v);
  898.     }
  899.  
  900.     // load interface parameters
  901.     v = FindToolType((UBYTE **) diskobj->do_ToolTypes,"WINDOW");
  902.     if (v)
  903.     {
  904.         GlbManagerWindowGeometry.Set = (sscanf(v,"%ld/%ld/%ld/%ld",
  905.             &GlbManagerWindowGeometry.LeftEdge,
  906.             &GlbManagerWindowGeometry.TopEdge,
  907.             &GlbManagerWindowGeometry.Width,
  908.             &GlbManagerWindowGeometry.Height) == 4);
  909.     }
  910.     v = FindToolType((UBYTE **) diskobj->do_ToolTypes,"PROPERTIES");
  911.     if (v)
  912.     {
  913.         UBYTE onoff[10];
  914.         GlbPropertiesWindowGeometry.Set = (sscanf(v,"%ld/%ld/%ld/%ld/%[^/]",
  915.             &GlbPropertiesWindowGeometry.LeftEdge,
  916.             &GlbPropertiesWindowGeometry.TopEdge,
  917.             &GlbPropertiesWindowGeometry.Width,
  918.             &GlbPropertiesWindowGeometry.Height,
  919.             &onoff) == 5);
  920.         GlbOpenPropertiesF = (Stricmp(onoff,"on") == 0);
  921.     }
  922.     v = FindToolType((UBYTE **) diskobj->do_ToolTypes,"SCREENMODEREQ");
  923.     if (v)
  924.     {
  925.         GlbScreenModeGeometry.Set = (sscanf(v,"%ld/%ld/%ld/%ld",
  926.             &GlbScreenModeGeometry.Left,
  927.             &GlbScreenModeGeometry.Top,
  928.             &GlbScreenModeGeometry.Width,
  929.             &GlbScreenModeGeometry.Height) == 4);
  930.     }
  931.     v = FindToolType((UBYTE **) diskobj->do_ToolTypes,"SCREENMODEINFO");
  932.     if (v)
  933.     {
  934.         GlbScreenModeGeometry.InfoSet = (sscanf(v,"%ld/%ld/%ld/%ld/%hd",
  935.             &GlbScreenModeGeometry.InfoLeft,
  936.             &GlbScreenModeGeometry.InfoTop,
  937.             &GlbScreenModeGeometry.InfoWidth,
  938.             &GlbScreenModeGeometry.InfoHeight,
  939.             &GlbScreenModeGeometry.InfoOpened) == 5);
  940.     }
  941.     v = FindToolType((UBYTE **) diskobj->do_ToolTypes,"FONTREQ");
  942.     if (v)
  943.     {
  944.         GlbFontGeometry.Set = (sscanf(v,"%ld/%ld/%ld/%ld",
  945.             &GlbFontGeometry.Left,
  946.             &GlbFontGeometry.Top,
  947.             &GlbFontGeometry.Width,
  948.             &GlbFontGeometry.Height) == 4);
  949.     }
  950.     FreeDiskObject(diskobj);
  951.     return NULL;
  952. }
  953.  
  954. // *************************************************************
  955. // ***
  956. // *** NAME      StripIDCMPMessages
  957. // *** FUNCTION  Reply messages before closing a window (should be in amiga.lib)
  958. // ***
  959. // *************************************************************
  960. void StripIDCMPMessages(struct Window *WinP)
  961. {
  962.     Forbid();
  963.     struct IntuiMessage *msg;
  964.     struct Node *succ;
  965.     msg = (struct IntuiMessage *) WinP->UserPort->mp_MsgList.lh_Head;
  966.     while (succ = msg->ExecMessage.mn_Node.ln_Succ)
  967.     {
  968.         if (msg->IDCMPWindow == WinP)
  969.         {
  970.             Remove(&msg->ExecMessage.mn_Node);
  971.             ReplyMsg(&msg->ExecMessage);
  972.         }
  973.         msg = (struct IntuiMessage *) succ;
  974.     }
  975.     WinP->UserPort = NULL;
  976.     ModifyIDCMP(WinP,0);
  977.     Permit();
  978. }
  979.  
  980. // *************************************************************
  981. // ***
  982. // *** NAME      error
  983. // *** FUNCTION  show error message, cleanup and exit
  984. // ***
  985. // *************************************************************
  986. void error(char *s)
  987. {
  988.     if (s)
  989.     {
  990.         if (GlbSurfaceP)
  991.         {
  992.             WZ_LockWindows(GlbSurfaceP);
  993.             WZ_EasyRequestArgs(GlbSurfaceP,GlbManagerWindowP,REQ_ERROR_ID,&s);
  994.             WZ_UnlockWindows(GlbSurfaceP);
  995.         }
  996.     }
  997.     if (GlbPropertiesWindowP)
  998.     {
  999.         StripIDCMPMessages(GlbPropertiesWindowP);
  1000.         WZ_CloseWindow(GlbPropertiesWindowHandleP);
  1001.     }
  1002.     if (GlbManagerWindowP)
  1003.     {
  1004.         StripIDCMPMessages(GlbManagerWindowP);
  1005.         WZ_CloseWindow(GlbManagerWindowHandleP);
  1006.     }
  1007.     if (GlbIDCMPortP)
  1008.         DeleteMsgPort(GlbIDCMPortP);
  1009.     if (GlbRexxPortP)
  1010.     {
  1011.         RemPort(GlbRexxPortP);
  1012.         struct RexxMsg *msg;
  1013.         while (msg = (struct RexxMsg *) GetMsg(GlbRexxPortP))
  1014.         {
  1015.             msg->rm_Result1 = RC_FATAL;
  1016.             ReplyMsg(&msg->rm_Node);
  1017.         }
  1018.         DeleteMsgPort(GlbRexxPortP);
  1019.     }
  1020.     if (GlbScreenSignal != ~0)
  1021.         FreeSignal(GlbScreenSignal);
  1022.     if (GlbPropertiesWindowHandleP)
  1023.         WZ_FreeWindowHandle(GlbPropertiesWindowHandleP);
  1024.     if (GlbManagerWindowHandleP)
  1025.         WZ_FreeWindowHandle(GlbManagerWindowHandleP);
  1026.     if (GlbSurfaceP)
  1027.         WZ_CloseSurface(GlbSurfaceP);
  1028.     if (GlbScreenP)
  1029.         UnlockPubScreen(NULL,GlbScreenP);
  1030.     if (GlbFontRequesterP)
  1031.         FreeAslRequest(GlbFontRequesterP);
  1032.     if (GlbScreenModeRequesterP)
  1033.         FreeAslRequest(GlbScreenModeRequesterP);
  1034.     FreeScreenList();
  1035.     if (GlbBrokerP)
  1036.     {
  1037.         DeleteCxObjAll(GlbBrokerP);
  1038.     }
  1039.     if (GlbBrokerPortP)
  1040.     {
  1041.         CxMsg *msg;
  1042.         while (msg = (CxMsg *) GetMsg(GlbBrokerPortP))
  1043.             ReplyMsg((struct Message *) msg);
  1044.         DeletePort(GlbBrokerPortP);
  1045.     }
  1046.     if (GlbCatalogP)
  1047.         CloseCatalog(GlbCatalogP);
  1048.     if (GlbCurrentDir)
  1049.         UnLock(CurrentDir(GlbCurrentDir));
  1050.     exit(s ? 20 : 0)
  1051. }
  1052.  
  1053. // *************************************************************
  1054. // ***
  1055. // *** NAME      setselected
  1056. // *** FUNCTION  Set all gadgets that reflect a screen node
  1057. // ***
  1058. // *************************************************************
  1059. void setselected()
  1060. {
  1061.     if (GlbManagerWindowHandleP)
  1062.     {
  1063.         ULONG selected;
  1064.         GetAttr(WLISTVIEWA_Selected,GlbManagerGadgets[GAD_MAN_LIST_ID],&selected);
  1065.         ActiveNodeP = GetScreenNode(selected);
  1066.         if (ActiveNodeP)
  1067.         {
  1068.             BOOL v = (!ActiveNodeP->StormScreenF) || ActiveNodeP->OpenF;
  1069.             SetGadgetAttrs(GlbManagerGadgets[GAD_MAN_NAME_ID],GlbManagerWindowP,NULL,
  1070.                 GA_Disabled,v,
  1071.                 WSTRINGA_String,ActiveNodeP->Name,
  1072.                 TAG_END);
  1073.             SetGadgetAttrs(GlbManagerGadgets[GAD_MAN_DELETE_ID],GlbManagerWindowP,NULL,
  1074.                 GA_Disabled,v,
  1075.                 TAG_END);
  1076.             SetGadgetAttrs(GlbManagerGadgets[GAD_MAN_MODE_ID],GlbManagerWindowP,NULL,
  1077.                 GA_Disabled,v,
  1078.                 TAG_END);
  1079.             SetGadgetAttrs(GlbManagerGadgets[GAD_MAN_FONT_ID],GlbManagerWindowP,NULL,
  1080.                 GA_Disabled,v,
  1081.                 TAG_END);
  1082.             SetGadgetAttrs(GlbManagerGadgets[GAD_MAN_OPEN_ID],GlbManagerWindowP,NULL,
  1083.                 GA_Disabled,!ActiveNodeP->StormScreenF,
  1084.                 WTOGGLEA_Checked,ActiveNodeP->OpenF,
  1085.                 TAG_END);
  1086.             SetGadgetAttrs(GlbManagerGadgets[GAD_MAN_OPENBEHIND_ID],GlbManagerWindowP,NULL,
  1087.                 GA_Disabled,!ActiveNodeP->StormScreenF,
  1088.                 WCHECKBOXA_Checked,ActiveNodeP->OpenBehindF,
  1089.                 TAG_END);
  1090.             if (GlbPropertiesWindowHandleP)
  1091.             {
  1092.                 SetGadgetAttrs(GlbPropertiesGadgets[GAD_PRP_COLORNUM_ID],GlbPropertiesWindowP,NULL,
  1093.                     WARGSA_Format,ActiveNodeP->StormScreenF ? "%ld" : "",
  1094.                     WARGSA_Arg0,1L << ActiveNodeP->Depth,
  1095.                     TAG_END);
  1096.                 SetGadgetAttrs(GlbPropertiesGadgets[GAD_PRP_WIDTH_ID],GlbPropertiesWindowP,NULL,
  1097.                     WARGSA_Format,ActiveNodeP->StormScreenF ? "%ld" : "",
  1098.                     WARGSA_Arg0,ActiveNodeP->Width,
  1099.                     TAG_END);
  1100.                 SetGadgetAttrs(GlbPropertiesGadgets[GAD_PRP_HEIGHT_ID],GlbPropertiesWindowP,NULL,
  1101.                     WARGSA_Format,ActiveNodeP->StormScreenF ? "%ld" : "",
  1102.                     WARGSA_Arg0,ActiveNodeP->Height,
  1103.                     TAG_END);
  1104.                 SetGadgetAttrs(GlbPropertiesGadgets[GAD_PRP_FONT_ID],GlbPropertiesWindowP,NULL,
  1105.                     GA_Disabled,v,
  1106.                     WCYCLEA_Active,ActiveNodeP->SysFont,
  1107.                     TAG_END);
  1108.                 SetGadgetAttrs(GlbPropertiesGadgets[GAD_PRP_TITLE_ID],GlbPropertiesWindowP,NULL,
  1109.                     GA_Disabled,v,
  1110.                     WSTRINGA_String,ActiveNodeP->Title,
  1111.                     TAG_END);
  1112.                 SetGadgetAttrs(GlbPropertiesGadgets[GAD_PRP_LIKEWB_ID],GlbPropertiesWindowP,NULL,
  1113.                     GA_Disabled,v,
  1114.                     WCHECKBOXA_Checked,ActiveNodeP->LikeWorkbenchF,
  1115.                     TAG_END);
  1116.                 SetGadgetAttrs(GlbPropertiesGadgets[GAD_PRP_CLOSEGADGET_ID],GlbPropertiesWindowP,NULL,
  1117.                     GA_Disabled,v,
  1118.                     WCHECKBOXA_Checked,ActiveNodeP->CloseGadgetF,
  1119.                     TAG_END);
  1120.                 SetGadgetAttrs(GlbPropertiesGadgets[GAD_PRP_DRAGGABLE_ID],GlbPropertiesWindowP,NULL,
  1121.                     GA_Disabled,v,
  1122.                     WCHECKBOXA_Checked,ActiveNodeP->DraggableF,
  1123.                     TAG_END);
  1124.                 SetGadgetAttrs(GlbPropertiesGadgets[GAD_PRP_QUIET_ID],GlbPropertiesWindowP,NULL,
  1125.                     GA_Disabled,v,
  1126.                     WCHECKBOXA_Checked,ActiveNodeP->QuietF,
  1127.                     TAG_END);
  1128.                 SetGadgetAttrs(GlbPropertiesGadgets[GAD_PRP_EXCLUSIVE_ID],GlbPropertiesWindowP,NULL,
  1129.                     GA_Disabled,v,
  1130.                     WCHECKBOXA_Checked,ActiveNodeP->ExclusiveF,
  1131.                     TAG_END);
  1132.             }
  1133.         }
  1134.         else
  1135.         {
  1136.             SetGadgetAttrs(GlbManagerGadgets[GAD_MAN_NAME_ID],GlbManagerWindowP,NULL,
  1137.                 GA_Disabled,TRUE,
  1138.                 WSTRINGA_String,"",
  1139.                 TAG_END);
  1140.             SetGadgetAttrs(GlbManagerGadgets[GAD_MAN_DELETE_ID],GlbManagerWindowP,NULL,
  1141.                 GA_Disabled,TRUE,
  1142.                 TAG_END);
  1143.             SetGadgetAttrs(GlbManagerGadgets[GAD_MAN_MODE_ID],GlbManagerWindowP,NULL,
  1144.                 GA_Disabled,TRUE,
  1145.                 TAG_END);
  1146.             SetGadgetAttrs(GlbManagerGadgets[GAD_MAN_FONT_ID],GlbManagerWindowP,NULL,
  1147.                 GA_Disabled,TRUE,
  1148.                 TAG_END);
  1149.             SetGadgetAttrs(GlbManagerGadgets[GAD_MAN_OPEN_ID],GlbManagerWindowP,NULL,
  1150.                 GA_Disabled,TRUE,
  1151.                 WCHECKBOXA_Checked,FALSE,
  1152.                 TAG_END);
  1153.             SetGadgetAttrs(GlbManagerGadgets[GAD_MAN_OPENBEHIND_ID],GlbManagerWindowP,NULL,
  1154.                 GA_Disabled,TRUE,
  1155.                 WCHECKBOXA_Checked,FALSE,
  1156.                 TAG_END);
  1157.             if (GlbPropertiesWindowHandleP)
  1158.             {
  1159.                 SetGadgetAttrs(GlbPropertiesGadgets[GAD_PRP_COLORNUM_ID],GlbPropertiesWindowP,NULL,
  1160.                     WARGSA_Format,"",
  1161.                     TAG_END);
  1162.                 SetGadgetAttrs(GlbPropertiesGadgets[GAD_PRP_WIDTH_ID],GlbPropertiesWindowP,NULL,
  1163.                     WARGSA_Format,"",
  1164.                     TAG_END);
  1165.                 SetGadgetAttrs(GlbPropertiesGadgets[GAD_PRP_HEIGHT_ID],GlbPropertiesWindowP,NULL,
  1166.                     WARGSA_Format,"",
  1167.                     TAG_END);
  1168.                 SetGadgetAttrs(GlbPropertiesGadgets[GAD_PRP_FONT_ID],GlbPropertiesWindowP,NULL,
  1169.                     GA_Disabled,TRUE,
  1170.                     WCYCLEA_Active,0,
  1171.                     TAG_END);
  1172.                 SetGadgetAttrs(GlbPropertiesGadgets[GAD_PRP_TITLE_ID],GlbPropertiesWindowP,NULL,
  1173.                     GA_Disabled,TRUE,
  1174.                     WSTRINGA_String,"",
  1175.                     TAG_END);
  1176.                 SetGadgetAttrs(GlbPropertiesGadgets[GAD_PRP_LIKEWB_ID],GlbPropertiesWindowP,NULL,
  1177.                     GA_Disabled,TRUE,
  1178.                     WCHECKBOXA_Checked,FALSE,
  1179.                     TAG_END);
  1180.                 SetGadgetAttrs(GlbPropertiesGadgets[GAD_PRP_CLOSEGADGET_ID],GlbPropertiesWindowP,NULL,
  1181.                     GA_Disabled,TRUE,
  1182.                     WCHECKBOXA_Checked,FALSE,
  1183.                     TAG_END);
  1184.                 SetGadgetAttrs(GlbPropertiesGadgets[GAD_PRP_DRAGGABLE_ID],GlbPropertiesWindowP,NULL,
  1185.                     GA_Disabled,TRUE,
  1186.                     WCHECKBOXA_Checked,FALSE,
  1187.                     TAG_END);
  1188.                 SetGadgetAttrs(GlbPropertiesGadgets[GAD_PRP_QUIET_ID],GlbPropertiesWindowP,NULL,
  1189.                     GA_Disabled,TRUE,
  1190.                     WCHECKBOXA_Checked,FALSE,
  1191.                     TAG_END);
  1192.                 SetGadgetAttrs(GlbPropertiesGadgets[GAD_PRP_EXCLUSIVE_ID],GlbPropertiesWindowP,NULL,
  1193.                     GA_Disabled,TRUE,
  1194.                     WCHECKBOXA_Checked,FALSE,
  1195.                     TAG_END);
  1196.             }
  1197.         }
  1198.     }
  1199. }
  1200.  
  1201. // *************************************************************
  1202. // ***
  1203. // *** NAME      setshanghai
  1204. // *** FUNCTION  set the global Shaghai flag
  1205. // ***
  1206. // *************************************************************
  1207. void setshanghai(BOOL checked)
  1208. {
  1209.     GlbShanghaiF = checked;
  1210.     ULONG mode = SetPubScreenModes(0);
  1211.     if (checked)
  1212.         SetPubScreenModes(mode | SHANGHAI);
  1213.     else
  1214.         SetPubScreenModes(mode & ~SHANGHAI);
  1215.     if (GlbManagerWindowHandleP)
  1216.     {
  1217.         SetGadgetAttrs(GlbManagerGadgets[GAD_MAN_SHANGHAI_ID],GlbManagerWindowP,NULL,
  1218.             WCHECKBOXA_Checked,GlbShanghaiF,
  1219.             TAG_END);
  1220.     }
  1221. }
  1222.  
  1223. // *************************************************************
  1224. // ***
  1225. // *** NAME      setautopopup
  1226. // *** FUNCTION  set the global AutoPopup flag
  1227. // ***
  1228. // *************************************************************
  1229. void setautopopup(BOOL checked)
  1230. {
  1231.     GlbAutoPopupF = checked;
  1232.     ULONG mode = SetPubScreenModes(0);
  1233.     if (checked)
  1234.         SetPubScreenModes(mode | POPPUBSCREEN);
  1235.     else
  1236.         SetPubScreenModes(mode & ~POPPUBSCREEN);
  1237.     if (GlbManagerWindowHandleP)
  1238.     {
  1239.         SetGadgetAttrs(GlbManagerGadgets[GAD_MAN_AUTOPOPUP_ID],GlbManagerWindowP,NULL,
  1240.             WCHECKBOXA_Checked,GlbAutoPopupF,
  1241.             TAG_END);
  1242.     }
  1243. }
  1244.  
  1245. // *************************************************************
  1246. // ***
  1247. // *** NAME      openscreen
  1248. // *** FUNCTION  open a public screen, close gadget etc
  1249. // ***
  1250. // *************************************************************
  1251. void openscreen(struct ScreenNode *node)
  1252. {
  1253.     struct TextFont *font = NULL;
  1254.     strcpy(node->ScreenTitle,strlen(node->Title) ? node->Title : node->Name);
  1255.     if (node->SysFont == 0)
  1256.         font = OpenDiskFont(&node->Font);
  1257.     if (node->Screen = OpenScreenTags(NULL,
  1258.             SA_Type,PUBLICSCREEN,
  1259.             SA_PubName,node->Name,
  1260.             SA_PubSig,GlbScreenSignal,
  1261.             SA_PubTask,NULL,
  1262.  
  1263.             SA_LikeWorkbench, node->LikeWorkbenchF,
  1264.             node->LikeWorkbenchF ? TAG_SKIP : TAG_IGNORE, 11,
  1265.             SA_DisplayID,node->ModeID,
  1266.             SA_Depth,node->Depth,
  1267.             SA_Overscan,node->Overscan,
  1268.             SA_Width,node->Width,
  1269.             SA_Height,node->Height,
  1270.             SA_FullPalette,TRUE,
  1271.             SA_Interleaved,TRUE,
  1272.             SA_Pens,node->Pens,
  1273.             node->SysFont == 0 ? SA_Font : TAG_IGNORE, &node->Font,
  1274.             node->SysFont != 0 ? SA_SysFont : TAG_IGNORE, node->SysFont-1,
  1275.             SA_SharePens,TRUE,
  1276.  
  1277.             SA_Title,node->CloseGadgetF ? "" : node->ScreenTitle,
  1278.             SA_AutoScroll,node->AutoScrollF,
  1279.             SA_Behind,node->OpenBehindF,
  1280.             SA_ShowTitle,FALSE,
  1281.             SA_Quiet,node->QuietF,
  1282.             SA_Exclusive,node->ExclusiveF,
  1283.             SA_Draggable,node->DraggableF,
  1284.             TAG_END))
  1285.     {
  1286.         node->OpenF = TRUE;
  1287.         if (node->CloseGadgetF)
  1288.         {
  1289.             struct DrawInfo *drawinfo = GetScreenDrawInfo(node->Screen);
  1290.             if (drawinfo)
  1291.             {
  1292.                 struct Image *closeimage = (struct Image *) NewObject(NULL,SYSICLASS,
  1293.                     SYSIA_DrawInfo,drawinfo,
  1294.                     SYSIA_Size,SYSISIZE_HIRES,
  1295.                     SYSIA_Which,CLOSEIMAGE,
  1296.                     font ? IA_Height : TAG_IGNORE, font ? font->tf_YSize+2 : 0,
  1297.                     TAG_END);
  1298.                 if (closeimage)
  1299.                 {
  1300.                     ULONG screenmodes;
  1301.                     // calculate Screentitle
  1302.                     #define SPACES "                            "
  1303.                     struct TextExtent textextent;
  1304.                     ULONG count = TextFit(&node->Screen->RastPort,
  1305.                         SPACES,strlen(SPACES),
  1306.                         &textextent,NULL,1,
  1307.                         closeimage->Width + 4, 1000);
  1308.                     sprintf(node->ScreenTitle,"%s%s",
  1309.                         SPACES+strlen(SPACES)-count,strlen(node->Title) == 0 ? node->Name : node->Title);
  1310.                     node->DefaultTitle = node->Screen->DefaultTitle;
  1311.                     node->Screen->DefaultTitle = node->ScreenTitle;
  1312.                     #undef SPACES
  1313.                     screenmodes = SetPubScreenModes(0);
  1314.                     SetPubScreenModes(screenmodes & ~(POPPUBSCREEN|SHANGHAI));
  1315.                     // This "invisible" window is used to refresh
  1316.                     // the screen title.
  1317.                     struct Window *win = OpenWindowTags(NULL,
  1318.                         WA_Activate,TRUE,
  1319.                         WA_Left,0,
  1320.                         WA_Top,0,
  1321.                         WA_Width,1,
  1322.                         WA_Height,1,
  1323.                         WA_Borderless,TRUE,
  1324.                         WA_CustomScreen,node->Screen,
  1325.                         WA_ScreenTitle,node->ScreenTitle,
  1326.                         TAG_END);
  1327.                     if (node->CloseGadget = OpenWindowTags(NULL,
  1328.                         WA_Activate,FALSE,
  1329.                         WA_Backdrop,TRUE,
  1330.                         WA_Borderless,TRUE,
  1331.                         WA_CloseGadget,TRUE,
  1332.                         WA_DepthGadget,FALSE,
  1333.                         WA_DragBar,FALSE,
  1334.                         WA_Left,0,
  1335.                         WA_Top,0,
  1336.                         WA_Width,closeimage->Width,
  1337.                         WA_Height,closeimage->Height,
  1338.                         WA_IDCMP,0,
  1339.                         WA_NoCareRefresh,TRUE,
  1340.                         WA_RMBTrap,TRUE,
  1341.                         WA_SimpleRefresh,TRUE,
  1342.                         WA_SizeGadget,FALSE,
  1343.                         WA_Title,NULL,
  1344.                         WA_ScreenTitle,node->ScreenTitle,
  1345.                         WA_CustomScreen,node->Screen,
  1346.                         TAG_END))
  1347.                     {
  1348.                         node->CloseGadget->UserPort = GlbIDCMPortP;
  1349.                         ModifyIDCMP(node->CloseGadget,IDCMP_CLOSEWINDOW);
  1350.                     }
  1351.                     if (win)
  1352.                         CloseWindow(win);
  1353.                     SetPubScreenModes(screenmodes);
  1354.                     DisposeObject(closeimage);
  1355.                 }
  1356.                 FreeScreenDrawInfo(node->Screen,drawinfo);
  1357.             }
  1358.         }
  1359.         PubScreenStatus(node->Screen,0);
  1360.     }
  1361.     else if (GlbSurfaceP)
  1362.     {
  1363.         STRPTR err = node->Name;
  1364.         WZ_LockWindows(GlbSurfaceP);
  1365.         WZ_EasyRequestArgs(GlbSurfaceP,GlbManagerWindowP,REQ_SCREENOPENERR_ID,&err);
  1366.         WZ_UnlockWindows(GlbSurfaceP);
  1367.     }
  1368.     if (font)
  1369.         CloseFont(font);
  1370. }
  1371.  
  1372. // *************************************************************
  1373. // ***
  1374. // *** NAME      closescreen
  1375. // *** FUNCTION  close a public screen
  1376. // ***
  1377. // *************************************************************
  1378. void closescreen(struct ScreenNode *node)
  1379. {
  1380.     if (node->CloseGadget)
  1381.     {
  1382.         StripIDCMPMessages(node->CloseGadget);
  1383.         CloseWindow(node->CloseGadget);
  1384.         node->CloseGadget = NULL;
  1385.     }
  1386.     if (node->Screen)
  1387.     {
  1388.         node->Screen->DefaultTitle = node->DefaultTitle;
  1389.         if (CloseScreen(node->Screen))
  1390.         {
  1391.             node->OpenF = FALSE;
  1392.             node->CloseSoonF = FALSE;
  1393.         }
  1394.         else
  1395.         {
  1396.             node->CloseSoonF = TRUE;
  1397.         }
  1398.     }
  1399. }
  1400.  
  1401. // *************************************************************
  1402. // ***
  1403. // *** NAME      closeproperties
  1404. // *** FUNCTION  close properties window
  1405. // ***
  1406. // *************************************************************
  1407. void closeproperties()
  1408. {
  1409.     if (GlbPropertiesWindowP)
  1410.     {
  1411.         GlbPropertiesWindowGeometry.LeftEdge = GlbPropertiesWindowP->LeftEdge;
  1412.         GlbPropertiesWindowGeometry.TopEdge = GlbPropertiesWindowP->TopEdge;
  1413.         GlbPropertiesWindowGeometry.Width = GlbPropertiesWindowP->Width;
  1414.         GlbPropertiesWindowGeometry.Height = GlbPropertiesWindowP->Height;
  1415.         GlbPropertiesWindowGeometry.Set = TRUE;
  1416.         StripIDCMPMessages(GlbPropertiesWindowP);
  1417.         WZ_CloseWindow(GlbPropertiesWindowHandleP);
  1418.         GlbPropertiesWindowP = NULL;
  1419.     }
  1420. }
  1421.  
  1422. // *************************************************************
  1423. // ***
  1424. // *** NAME      openproperties
  1425. // *** FUNCTION  open properties window
  1426. // ***
  1427. // *************************************************************
  1428. void openproperties(BOOL activate)
  1429. {
  1430.     if (!GlbPropertiesWindowHandleP)
  1431.     {
  1432.         if (!(GlbPropertiesWindowHandleP = WZ_AllocWindowHandle(GlbScreenP,0,GlbSurfaceP,
  1433.             TAG_END)))
  1434.         {
  1435.             error(getlocalestr(MSG_OUT_OF_MEMORY_ID,MSG_OUT_OF_MEMORY_ID_STR));
  1436.         }
  1437.     }
  1438.     if (!GlbPropertiesNewWindowP)
  1439.     {
  1440.         if (!(GlbPropertiesNewWindowP = WZ_CreateWindowObj(GlbPropertiesWindowHandleP,PROPERTIESWIN_ID,
  1441.             WWH_GadgetArray,GlbPropertiesGadgets,
  1442.             TAG_END)))
  1443.         {
  1444.             error(getlocalestr(MSG_FATAL_ID,MSG_FATAL_ID_STR));
  1445.         }
  1446.     }
  1447.     if (!GlbPropertiesWindowP)
  1448.     {
  1449.         struct NewWindow *nw = GlbPropertiesNewWindowP;
  1450.         if (GlbPropertiesWindowGeometry.Set)
  1451.         {
  1452.             nw->LeftEdge = GlbPropertiesWindowGeometry.LeftEdge;
  1453.             nw->TopEdge = GlbPropertiesWindowGeometry.TopEdge;
  1454.             nw->Width = GlbPropertiesWindowGeometry.Width;
  1455.             nw->Height = GlbPropertiesWindowGeometry.Height;
  1456.         }
  1457.         if (nw->Width < nw->MinWidth)
  1458.             nw->Width = nw->MinWidth;
  1459.         nw->Height = nw->MaxHeight = nw->MinHeight;
  1460.         if (!(GlbPropertiesWindowP = WZ_OpenWindow(GlbPropertiesWindowHandleP,GlbPropertiesNewWindowP,
  1461.             WA_IDCMP,0,
  1462.             WA_AutoAdjust,TRUE,
  1463.             WA_Activate,activate,
  1464.             TAG_END)))
  1465.         {
  1466.             error(getlocalestr(MSG_FATAL_ID,MSG_FATAL_ID_STR));
  1467.         }
  1468.         GlbPropertiesWindowP->UserPort = GlbIDCMPortP;
  1469.         ModifyIDCMP(GlbPropertiesWindowP,GlbPropertiesNewWindowP->IDCMPFlags);
  1470.     }
  1471.     else
  1472.     {
  1473.         WindowToFront(GlbPropertiesWindowP);
  1474.         if (activate)
  1475.             ActivateWindow(GlbPropertiesWindowP);
  1476.     }
  1477. }
  1478.  
  1479. // *************************************************************
  1480. // ***
  1481. // *** NAME      hide
  1482. // *** FUNCTION  hide user interface, remember state of properties window
  1483. // ***
  1484. // *************************************************************
  1485. void hide()
  1486. {
  1487.     if (GlbPropertiesWindowP)
  1488.         GlbOpenPropertiesF = TRUE;
  1489.     closeproperties();
  1490.     if (GlbPropertiesWindowHandleP)
  1491.     {
  1492.         WZ_FreeWindowHandle(GlbPropertiesWindowHandleP);
  1493.         GlbPropertiesWindowHandleP = NULL;
  1494.         GlbPropertiesNewWindowP = NULL;
  1495.     }
  1496.     if (GlbManagerWindowP)
  1497.     {
  1498.         GlbManagerWindowGeometry.LeftEdge = GlbManagerWindowP->LeftEdge;
  1499.         GlbManagerWindowGeometry.TopEdge = GlbManagerWindowP->TopEdge;
  1500.         GlbManagerWindowGeometry.Width = GlbManagerWindowP->Width;
  1501.         GlbManagerWindowGeometry.Height = GlbManagerWindowP->Height;
  1502.         GlbManagerWindowGeometry.Set = TRUE;
  1503.         StripIDCMPMessages(GlbManagerWindowP);
  1504.         WZ_CloseWindow(GlbManagerWindowHandleP);
  1505.         GlbManagerWindowP = NULL;
  1506.     }
  1507.     if (GlbManagerWindowHandleP)
  1508.     {
  1509.         WZ_FreeWindowHandle(GlbManagerWindowHandleP);
  1510.         GlbManagerWindowHandleP = NULL;
  1511.         GlbManagerNewWindowP = NULL;
  1512.     }
  1513.     if (GlbFontRequesterP)
  1514.     {
  1515.         GlbFontGeometry.Left = GlbFontRequesterP->fo_LeftEdge;
  1516.         GlbFontGeometry.Top = GlbFontRequesterP->fo_TopEdge;
  1517.         GlbFontGeometry.Width = GlbFontRequesterP->fo_Width;
  1518.         GlbFontGeometry.Height = GlbFontRequesterP->fo_Height;
  1519.         GlbFontGeometry.Set = TRUE;
  1520.         FreeAslRequest(GlbFontRequesterP);
  1521.         GlbFontRequesterP = NULL;
  1522.     }
  1523.     if (GlbScreenModeRequesterP)
  1524.     {
  1525.         GlbScreenModeGeometry.Left = GlbScreenModeRequesterP->sm_LeftEdge;
  1526.         GlbScreenModeGeometry.Top = GlbScreenModeRequesterP->sm_TopEdge;
  1527.         GlbScreenModeGeometry.Width = GlbScreenModeRequesterP->sm_Width;
  1528.         GlbScreenModeGeometry.Height = GlbScreenModeRequesterP->sm_Height;
  1529.         GlbScreenModeGeometry.InfoOpened = GlbScreenModeRequesterP->sm_InfoOpened;
  1530.         GlbScreenModeGeometry.InfoLeft = GlbScreenModeRequesterP->sm_InfoLeftEdge;
  1531.         GlbScreenModeGeometry.InfoTop = GlbScreenModeRequesterP->sm_InfoTopEdge;
  1532.         GlbScreenModeGeometry.InfoWidth = GlbScreenModeRequesterP->sm_InfoWidth;
  1533.         GlbScreenModeGeometry.InfoHeight = GlbScreenModeRequesterP->sm_InfoHeight;
  1534.         GlbScreenModeGeometry.InfoSet = TRUE;
  1535.         GlbScreenModeGeometry.Set = TRUE;
  1536.         FreeAslRequest(GlbScreenModeRequesterP);
  1537.         GlbScreenModeRequesterP = NULL;
  1538.     }
  1539.     if (GlbScreenP)
  1540.     {
  1541.         UnlockPubScreen(NULL,GlbScreenP);
  1542.         GlbScreenP = NULL;
  1543.     }
  1544. }
  1545.  
  1546. // *************************************************************
  1547. // ***
  1548. // *** NAME      show
  1549. // *** FUNCTION  show user interface, open properties window?
  1550. // ***
  1551. // *************************************************************
  1552. void show()
  1553. {
  1554.     if (!GlbScreenP)
  1555.     {
  1556.         if (!(GlbScreenP = LockPubScreen(NULL)))
  1557.             error(getlocalestr(MSG_FATAL_ID,MSG_FATAL_ID_STR));
  1558.     }
  1559.     if (!GlbManagerWindowHandleP)
  1560.     {
  1561.         if (!(GlbManagerWindowHandleP = WZ_AllocWindowHandle(GlbScreenP,0,GlbSurfaceP,
  1562.             TAG_END)))
  1563.         {
  1564.             error(getlocalestr(MSG_OUT_OF_MEMORY_ID,MSG_OUT_OF_MEMORY_ID_STR));
  1565.         }
  1566.     }
  1567.     if (!GlbManagerNewWindowP)
  1568.     {
  1569.         if (!(GlbManagerNewWindowP = WZ_CreateWindowObj(GlbManagerWindowHandleP,MANAGERWIN_ID,
  1570.             WWH_GadgetArray,GlbManagerGadgets,
  1571.             TAG_END)))
  1572.         {
  1573.             error(getlocalestr(MSG_FATAL_ID,MSG_FATAL_ID_STR));
  1574.         }
  1575.     }
  1576.     SetGadgetAttrs(GlbManagerGadgets[GAD_MAN_LIST_ID],NULL,NULL,
  1577.         WLISTVIEWA_HeaderNode,&HeaderNode,
  1578.         WLISTVIEWA_List,&ScreenList,
  1579.         WLISTVIEWA_Columns,6,
  1580.         TAG_END);
  1581.     SetGadgetAttrs(GlbManagerGadgets[GAD_MAN_SHANGHAI_ID],GlbManagerWindowP,NULL,
  1582.         WCHECKBOXA_Checked,GlbShanghaiF,
  1583.         TAG_END);
  1584.     SetGadgetAttrs(GlbManagerGadgets[GAD_MAN_AUTOPOPUP_ID],GlbManagerWindowP,NULL,
  1585.         WCHECKBOXA_Checked,GlbAutoPopupF,
  1586.         TAG_END);
  1587.     if (!GlbManagerWindowP)
  1588.     {
  1589.         struct NewWindow *nw = GlbManagerNewWindowP;
  1590.         if (GlbManagerWindowGeometry.Set)
  1591.         {
  1592.             nw->LeftEdge = GlbManagerWindowGeometry.LeftEdge;
  1593.             nw->TopEdge = GlbManagerWindowGeometry.TopEdge;
  1594.             nw->Width = GlbManagerWindowGeometry.Width;
  1595.             nw->Height = GlbManagerWindowGeometry.Height;
  1596.         }
  1597.         if (nw->Width < nw->MinWidth)
  1598.             nw->Width = nw->MinWidth;
  1599.         if (nw->Height < nw->MinHeight)
  1600.             nw->Height = nw->MinHeight;
  1601.         if (!(GlbManagerWindowP = WZ_OpenWindow(GlbManagerWindowHandleP,GlbManagerNewWindowP,
  1602.             WA_IDCMP,0,
  1603.             WA_AutoAdjust,TRUE,
  1604.             TAG_END)))
  1605.         {
  1606.             error(getlocalestr(MSG_FATAL_ID,MSG_FATAL_ID_STR));
  1607.         }
  1608.         GlbManagerWindowP->UserPort = GlbIDCMPortP;
  1609.         ModifyIDCMP(GlbManagerWindowP,GlbManagerNewWindowP->IDCMPFlags);
  1610.     }
  1611.     else
  1612.     {
  1613.         WindowToFront(GlbManagerWindowP);
  1614.         ActivateWindow(GlbManagerWindowP);
  1615.     }
  1616.     if (GlbOpenPropertiesF)
  1617.         openproperties(FALSE);
  1618.     setselected();
  1619. }
  1620.  
  1621. // *************************************************************
  1622. // ***
  1623. // *** NAME      handlemanagerwindow
  1624. // *** FUNCTION  handle all IDCMP messages for the main window
  1625. // ***
  1626. // *************************************************************
  1627. BOOL handlemanagerwindow(struct IntuiMessage *msg)
  1628. {
  1629.     BOOL retval = FALSE;
  1630.     switch (msg->Class)
  1631.     {
  1632.         case IDCMP_IDCMPUPDATE:
  1633.             switch (GetTagData(GA_ID,-1,(struct TagItem *) msg->IAddress))
  1634.             {
  1635.                 case GAD_MAN_LIST_ID:
  1636.                     if (GetTagData(WLISTVIEWA_DoubleClick,FALSE,(struct TagItem *) msg->IAddress))
  1637.                     {
  1638.                         SetGadgetAttrs(GlbManagerGadgets[GAD_MAN_LIST_ID],NULL,NULL,
  1639.                             WLISTVIEWA_List,NULL,
  1640.                             TAG_END);
  1641.                         SetDefaultScreenNode(ActiveNodeP);
  1642.                         SetGadgetAttrs(GlbManagerGadgets[GAD_MAN_LIST_ID],GlbManagerWindowP,NULL,
  1643.                             WLISTVIEWA_List,&ScreenList,
  1644.                             TAG_END);
  1645.                     }
  1646.                     else
  1647.                         setselected();
  1648.                     break;
  1649.                 case GAD_MAN_NAME_ID:
  1650.                 {
  1651.                     STRPTR name;
  1652.                     GetAttr(WSTRINGA_String,GlbManagerGadgets[GAD_MAN_NAME_ID],(ULONG *) &name);
  1653.                     if (ActiveNodeP)
  1654.                     {
  1655.                         SetGadgetAttrs(GlbManagerGadgets[GAD_MAN_LIST_ID],NULL,NULL,
  1656.                             WLISTVIEWA_List,NULL,
  1657.                             TAG_END);
  1658.                         SetScreenName(ActiveNodeP,name);
  1659.                         SetGadgetAttrs(GlbManagerGadgets[GAD_MAN_LIST_ID],GlbManagerWindowP,NULL,
  1660.                             WLISTVIEWA_List,&ScreenList,
  1661.                             TAG_END);
  1662.                     }
  1663.                     break;
  1664.                 }
  1665.                 case GAD_MAN_NEW_ID:
  1666.                 {
  1667.                     struct ScreenNode *node;
  1668.                     UBYTE Name[MAXPUBSCREENNAME];
  1669.                     ULONG i = 1;
  1670.                     strcpy(Name,"StormScreen");
  1671.                     while (FindScreenNode(Name))
  1672.                     {
  1673.                         sprintf(Name,"StormScreen.%ld",i);
  1674.                         i++;
  1675.                     }
  1676.                     if (node = AllocScreenNode(Name))
  1677.                     {
  1678.                         node->StormScreenF = TRUE;
  1679.                         struct Screen *screen = LockPubScreen(NULL);
  1680.                         SetScreenMode(node,GetVPModeID(&screen->ViewPort),
  1681.                             screen->RastPort.BitMap->Depth,
  1682.                             screen->Height,
  1683.                             screen->Width,
  1684.                             OSCAN_TEXT,
  1685.                             TRUE);
  1686.                         SetScreenFont(node,screen->Font);
  1687.                         UnlockPubScreen(NULL,screen);
  1688.                         SetGadgetAttrs(GlbManagerGadgets[GAD_MAN_LIST_ID],NULL,NULL,
  1689.                             WLISTVIEWA_List,NULL,
  1690.                             TAG_END);
  1691.                         AddScreenNode(node);
  1692.                         SetGadgetAttrs(GlbManagerGadgets[GAD_MAN_LIST_ID],GlbManagerWindowP,NULL,
  1693.                             WLISTVIEWA_List,&ScreenList,
  1694.                             WLISTVIEWA_Selected,GetScreenNodeIndex(node),
  1695.                             TAG_END);
  1696.                         setselected();
  1697.                     }
  1698.                     break;
  1699.                 }
  1700.                 case GAD_MAN_DELETE_ID:
  1701.                     if (ActiveNodeP)
  1702.                     {
  1703.                         SetGadgetAttrs(GlbManagerGadgets[GAD_MAN_LIST_ID],NULL,NULL,
  1704.                             WLISTVIEWA_List,NULL,
  1705.                             TAG_END);
  1706.                         RemScreenNode(ActiveNodeP);
  1707.                         FreeScreenNode(ActiveNodeP);
  1708.                         SetGadgetAttrs(GlbManagerGadgets[GAD_MAN_LIST_ID],GlbManagerWindowP,NULL,
  1709.                             WLISTVIEWA_List,&ScreenList,
  1710.                             WLISTVIEWA_Selected,-1,
  1711.                             TAG_END);
  1712.                         setselected();
  1713.                     }
  1714.                     break;
  1715.                 case GAD_MAN_MODE_ID:
  1716.                     if (ActiveNodeP)
  1717.                     {
  1718.                         WZ_LockWindows(GlbSurfaceP);
  1719.                         if (!GlbScreenModeRequesterP)
  1720.                         {
  1721.                             struct TagItem ScreenModeInfoTags[] =
  1722.                             {
  1723.                                 { ASLSM_InitialInfoLeftEdge, GlbScreenModeGeometry.InfoLeft },
  1724.                                 { ASLSM_InitialInfoTopEdge, GlbScreenModeGeometry.InfoTop },
  1725.                         //        { ASLSM_InitialInfoWidth, GlbScreenModeGeometry.InfoWidth },
  1726.                         //        { ASLSM_InitialInfoHeight, GlbScreenModeGeometry.InfoHeight },
  1727.                                 { TAG_END }
  1728.                             };
  1729.                             struct TagItem ScreenModeTags[] =
  1730.                             {
  1731.                                 { ASLSM_InitialLeftEdge, GlbScreenModeGeometry.Left },
  1732.                                 { ASLSM_InitialTopEdge, GlbScreenModeGeometry.Top },
  1733.                                 { ASLSM_InitialWidth, GlbScreenModeGeometry.Width },
  1734.                                 { ASLSM_InitialHeight, GlbScreenModeGeometry.Height },
  1735.                                 { GlbScreenModeGeometry.InfoSet ? TAG_MORE : TAG_END, (ULONG) ScreenModeInfoTags }
  1736.                             };
  1737.                             if (!(GlbScreenModeRequesterP = (struct ScreenModeRequester *) AllocAslRequestTags(ASL_ScreenModeRequest,
  1738.                                 ASLSM_PrivateIDCMP,TRUE,
  1739.                                 ASLSM_Screen,GlbScreenP,
  1740.                                 ASLSM_TitleText,getlocalestr(MSG_SELECT_SCREEN_MODE_ID,MSG_SELECT_SCREEN_MODE_ID_STR),
  1741.                                 GlbScreenModeGeometry.Set ? TAG_MORE : TAG_END, ScreenModeTags)))
  1742.                             {
  1743.                                 error(getlocalestr(MSG_FATAL_ID,MSG_FATAL_ID_STR));
  1744.                             }
  1745.                         }
  1746.                         if (AslRequestTags(GlbScreenModeRequesterP,
  1747.                             ASLSM_InitialDisplayDepth,ActiveNodeP->Depth,
  1748.                             ASLSM_InitialDisplayHeight,ActiveNodeP->Height,
  1749.                             ASLSM_InitialDisplayWidth,ActiveNodeP->Width,
  1750.                             ASLSM_InitialDisplayID,ActiveNodeP->ModeID,
  1751.                             ASLSM_InitialOverscanType,ActiveNodeP->Overscan,
  1752.                             ASLSM_DoAutoScroll,TRUE,
  1753.                             ASLSM_DoDepth,TRUE,
  1754.                             ASLSM_DoHeight,TRUE,
  1755.                             ASLSM_DoWidth,TRUE,
  1756.                             ASLSM_DoOverscanType,TRUE,
  1757.                             TAG_END))
  1758.                         {
  1759.                             SetGadgetAttrs(GlbManagerGadgets[GAD_MAN_LIST_ID],NULL,NULL,
  1760.                                 WLISTVIEWA_List,NULL,
  1761.                                 TAG_END);
  1762.                             SetScreenMode(ActiveNodeP,
  1763.                                 GlbScreenModeRequesterP->sm_DisplayID,
  1764.                                 GlbScreenModeRequesterP->sm_DisplayDepth,
  1765.                                 GlbScreenModeRequesterP->sm_DisplayHeight,
  1766.                                 GlbScreenModeRequesterP->sm_DisplayWidth,
  1767.                                 GlbScreenModeRequesterP->sm_OverscanType,
  1768.                                 GlbScreenModeRequesterP->sm_AutoScroll);
  1769.                             SetGadgetAttrs(GlbManagerGadgets[GAD_MAN_LIST_ID],GlbManagerWindowP,NULL,
  1770.                                 WLISTVIEWA_List,&ScreenList,
  1771.                                 TAG_END);
  1772.                         }
  1773.                         setselected();
  1774.                         WZ_UnlockWindows(GlbSurfaceP);
  1775.                     }
  1776.                     break;
  1777.                 case GAD_MAN_FONT_ID:
  1778.                     if (ActiveNodeP)
  1779.                     {
  1780.                         WZ_LockWindows(GlbSurfaceP);
  1781.                         if (!GlbFontRequesterP)
  1782.                         {
  1783.                             struct TagItem FontReqTags[] =
  1784.                             {
  1785.                                 { ASLFO_InitialLeftEdge, GlbFontGeometry.Left },
  1786.                                 { ASLFO_InitialTopEdge, GlbFontGeometry.Top },
  1787.                                 { ASLFO_InitialWidth, GlbFontGeometry.Width },
  1788.                                 { ASLFO_InitialHeight, GlbFontGeometry.Height },
  1789.                                 { TAG_END }
  1790.                             };
  1791.                             if (!(GlbFontRequesterP = (struct FontRequester *) AllocAslRequestTags(ASL_FontRequest,
  1792.                                 ASLFO_PrivateIDCMP,TRUE,
  1793.                                 ASLFO_Screen,GlbScreenP,
  1794.                                 ASLFO_TitleText,getlocalestr(MSG_SELECT_FONT_ID,MSG_SELECT_FONT_ID_STR),
  1795.                                 GlbFontGeometry.Set ? TAG_MORE : TAG_END, FontReqTags)))
  1796.                             {
  1797.                                 error(getlocalestr(MSG_FATAL_ID,MSG_FATAL_ID_STR));
  1798.                             }
  1799.                         }
  1800.                         if (AslRequestTags(GlbFontRequesterP,
  1801.                             ASLFO_InitialName,ActiveNodeP->Font.ta_Name,
  1802.                             ASLFO_InitialSize,ActiveNodeP->Font.ta_YSize,
  1803.                             TAG_END))
  1804.                         {
  1805.                             SetGadgetAttrs(GlbManagerGadgets[GAD_MAN_LIST_ID],NULL,NULL,
  1806.                                 WLISTVIEWA_List,NULL,
  1807.                                 TAG_END);
  1808.                             SetScreenFont(ActiveNodeP,&GlbFontRequesterP->fo_Attr);
  1809.                             SetGadgetAttrs(GlbManagerGadgets[GAD_MAN_LIST_ID],GlbManagerWindowP,NULL,
  1810.                                 WLISTVIEWA_List,&ScreenList,
  1811.                                 TAG_END);
  1812.                         }
  1813.                         setselected();
  1814.                         WZ_UnlockWindows(GlbSurfaceP);
  1815.                     }
  1816.                     break;
  1817.                 case GAD_MAN_OPEN_ID:
  1818.                     if (ActiveNodeP)
  1819.                     {
  1820.                         ULONG openf;
  1821.                         GetAttr(WTOGGLEA_Checked,GlbManagerGadgets[GAD_MAN_OPEN_ID],&openf);
  1822.                         if (openf && !ActiveNodeP->OpenF)
  1823.                         {
  1824.                             openscreen(ActiveNodeP);
  1825.                             GlbExitSoonF = FALSE;
  1826.                         }
  1827.                         else if (!openf && ActiveNodeP->OpenF)
  1828.                         {
  1829.                             closescreen(ActiveNodeP);
  1830.                         }
  1831.                         SetGadgetAttrs(GlbManagerGadgets[GAD_MAN_LIST_ID],NULL,NULL,
  1832.                             WLISTVIEWA_List,NULL,
  1833.                             TAG_END);
  1834.                         GetDefaultScreenNode();
  1835.                         SetGadgetAttrs(GlbManagerGadgets[GAD_MAN_LIST_ID],GlbManagerWindowP,NULL,
  1836.                             WLISTVIEWA_List,&ScreenList,
  1837.                             TAG_END);
  1838.                         setselected();
  1839.                     }
  1840.                     break;
  1841.                 case GAD_MAN_OPENBEHIND_ID:
  1842.                     if (ActiveNodeP)
  1843.                     {
  1844.                         ULONG checked;
  1845.                         GetAttr(WCHECKBOXA_Checked,GlbManagerGadgets[GAD_MAN_OPENBEHIND_ID],&checked);
  1846.                         ActiveNodeP->OpenBehindF = checked;
  1847.                     }
  1848.                     break;
  1849.                 case GAD_MAN_PROPERTIES_ID:
  1850.                     openproperties(TRUE);
  1851.                     setselected();
  1852.                     break;
  1853.                 case GAD_MAN_SHANGHAI_ID:
  1854.                 {
  1855.                     ULONG checked;
  1856.                     GetAttr(WCHECKBOXA_Checked,GlbManagerGadgets[GAD_MAN_SHANGHAI_ID],&checked);
  1857.                     setshanghai(checked);
  1858.                     break;
  1859.                 }
  1860.                 case GAD_MAN_AUTOPOPUP_ID:
  1861.                 {
  1862.                     ULONG checked;
  1863.                     GetAttr(WCHECKBOXA_Checked,GlbManagerGadgets[GAD_MAN_AUTOPOPUP_ID],&checked);
  1864.                     setautopopup(checked);
  1865.                     break;
  1866.                 }
  1867.             }
  1868.             break;
  1869.         case IDCMP_VANILLAKEY:
  1870.             if (!WZ_GadgetKeyA(GlbManagerWindowHandleP,msg->Code,msg->Qualifier,NULL))
  1871.             {
  1872.                 switch (msg->Code)
  1873.                 {
  1874.                     case 0x1b: // ESC
  1875.                         hide();
  1876.                         msg = NULL;
  1877.                         break;
  1878.                 }
  1879.             }
  1880.             break;
  1881.         case IDCMP_RAWKEY:
  1882.             switch (msg->Code)
  1883.             {
  1884.                 case 0x4c: // cursor up
  1885.                 {
  1886.                     ULONG selected;
  1887.                     GetAttr(WLISTVIEWA_Selected,GlbManagerGadgets[GAD_MAN_LIST_ID],&selected);
  1888.                     ULONG l = LengthOfScreenList();
  1889.                     if (l > 0)
  1890.                     {
  1891.                         if (selected == ~0)
  1892.                             selected = 0;
  1893.                         else if (selected > 0)
  1894.                             selected--;
  1895.                         else
  1896.                             selected = LengthOfScreenList() - 1;
  1897.                     }
  1898.                     SetGadgetAttrs(GlbManagerGadgets[GAD_MAN_LIST_ID],GlbManagerWindowP,NULL,
  1899.                         WLISTVIEWA_Selected,selected,
  1900.                         TAG_END);
  1901.                     setselected();
  1902.                     break;
  1903.                 }
  1904.                 case 0x4d: // cursor down
  1905.                 {
  1906.                     ULONG selected;
  1907.                     GetAttr(WLISTVIEWA_Selected,GlbManagerGadgets[GAD_MAN_LIST_ID],&selected);
  1908.                     ULONG l = LengthOfScreenList();
  1909.                     if (l > 0)
  1910.                     {
  1911.                         if (selected == ~0)
  1912.                             selected = 0;
  1913.                         else if (selected < l - 1)
  1914.                             selected++;
  1915.                         else
  1916.                             selected = 0;
  1917.                     }
  1918.                     SetGadgetAttrs(GlbManagerGadgets[GAD_MAN_LIST_ID],GlbManagerWindowP,NULL,
  1919.                         WLISTVIEWA_Selected,selected,
  1920.                         TAG_END);
  1921.                     setselected();
  1922.                     break;
  1923.                 }
  1924.                 case 0x44: // return == double click
  1925.                     SetGadgetAttrs(GlbManagerGadgets[GAD_MAN_LIST_ID],NULL,NULL,
  1926.                         WLISTVIEWA_List,NULL,
  1927.                         TAG_END);
  1928.                     SetDefaultScreenNode(ActiveNodeP);
  1929.                     SetGadgetAttrs(GlbManagerGadgets[GAD_MAN_LIST_ID],GlbManagerWindowP,NULL,
  1930.                         WLISTVIEWA_List,&ScreenList,
  1931.                         TAG_END);
  1932.                     break;
  1933.             }
  1934.             break;
  1935.         case IDCMP_CLOSEWINDOW:
  1936.             hide();
  1937.             msg = NULL;
  1938.             break;
  1939.         case IDCMP_MENUPICK:
  1940.         {
  1941.             UWORD code = msg->Code;
  1942.             while (code != MENUNULL)
  1943.             {
  1944.                 switch (code)
  1945.                 {
  1946.                     case PROJECT_SAVE_ID:
  1947.                     {
  1948.                         STRPTR err = Save(GlbProgramNameP);
  1949.                         if (err)
  1950.                             error(err);
  1951.                         break;
  1952.                     }
  1953.                     case PROJECT_ABOUT_ID:
  1954.                         WZ_LockWindows(GlbSurfaceP);
  1955.                         WZ_EasyRequestArgs(GlbSurfaceP,GlbManagerWindowP,REQ_ABOUT_ID,NULL);
  1956.                         WZ_UnlockWindows(GlbSurfaceP);
  1957.                         break;
  1958.                     case PROJECT_HIDE_ID:
  1959.                         hide();
  1960.                         msg = NULL;
  1961.                         break;
  1962.                     case PROJECT_QUIT_ID:
  1963.                         retval = TRUE;
  1964.                         break;
  1965.                 }
  1966.                 if (!msg)
  1967.                     break;
  1968.                 code = ItemAddress(GlbManagerWindowP->MenuStrip,code)->NextSelect;
  1969.             }
  1970.             break;
  1971.         }
  1972.     }
  1973.     if (msg)
  1974.         ReplyMsg(&msg->ExecMessage);
  1975.     return retval;
  1976. }
  1977.  
  1978. // *************************************************************
  1979. // ***
  1980. // *** NAME      handlepropertieswindow
  1981. // *** FUNCTION  handle all IDCMP messages for the properties window
  1982. // ***
  1983. // *************************************************************
  1984. BOOL handlepropertieswindow(struct IntuiMessage *msg)
  1985. {
  1986.     BOOL retval = FALSE;
  1987.     switch (msg->Class)
  1988.     {
  1989.         case IDCMP_IDCMPUPDATE:
  1990.             switch (GetTagData(GA_ID,-1,(struct TagItem *) msg->IAddress))
  1991.             {
  1992.                 case GAD_PRP_FONT_ID:
  1993.                     if (ActiveNodeP)
  1994.                     {
  1995.                         ULONG selected;
  1996.                         GetAttr(WCYCLEA_Active,GlbPropertiesGadgets[GAD_PRP_FONT_ID],&selected);
  1997.                         ActiveNodeP->SysFont = selected;
  1998.                     }
  1999.                     break;
  2000.                 case GAD_PRP_TITLE_ID:
  2001.                     if (ActiveNodeP)
  2002.                     {
  2003.                         STRPTR str;
  2004.                         GetAttr(WSTRINGA_String,GlbPropertiesGadgets[GAD_PRP_TITLE_ID],(ULONG *) &str);
  2005.                         strcpy(ActiveNodeP->Title,str);
  2006.                     }
  2007.                     break;
  2008.                 case GAD_PRP_LIKEWB_ID:
  2009.                     if (ActiveNodeP)
  2010.                     {
  2011.                         ULONG checked;
  2012.                         GetAttr(WCHECKBOXA_Checked,GlbPropertiesGadgets[GAD_PRP_LIKEWB_ID],&checked);
  2013.                         ActiveNodeP->LikeWorkbenchF = checked;
  2014.                     }
  2015.                     break;
  2016.                 case GAD_PRP_CLOSEGADGET_ID:
  2017.                     if (ActiveNodeP)
  2018.                     {
  2019.                         ULONG checked;
  2020.                         GetAttr(WCHECKBOXA_Checked,GlbPropertiesGadgets[GAD_PRP_CLOSEGADGET_ID],&checked);
  2021.                         ActiveNodeP->CloseGadgetF = checked;
  2022.                     }
  2023.                     break;
  2024.                 case GAD_PRP_DRAGGABLE_ID:
  2025.                     if (ActiveNodeP)
  2026.                     {
  2027.                         ULONG checked;
  2028.                         GetAttr(WCHECKBOXA_Checked,GlbPropertiesGadgets[GAD_PRP_DRAGGABLE_ID],&checked);
  2029.                         ActiveNodeP->DraggableF = checked;
  2030.                     }
  2031.                     break;
  2032.                 case GAD_PRP_QUIET_ID:
  2033.                     if (ActiveNodeP)
  2034.                     {
  2035.                         ULONG checked;
  2036.                         GetAttr(WCHECKBOXA_Checked,GlbPropertiesGadgets[GAD_PRP_QUIET_ID],&checked);
  2037.                         ActiveNodeP->QuietF = checked;
  2038.                     }
  2039.                     break;
  2040.                 case GAD_PRP_EXCLUSIVE_ID:
  2041.                     if (ActiveNodeP)
  2042.                     {
  2043.                         ULONG checked;
  2044.                         GetAttr(WCHECKBOXA_Checked,GlbPropertiesGadgets[GAD_PRP_EXCLUSIVE_ID],&checked);
  2045.                         ActiveNodeP->ExclusiveF = checked;
  2046.                     }
  2047.                     break;
  2048.             }
  2049.             break;
  2050.         case IDCMP_VANILLAKEY:
  2051.             if (!WZ_GadgetKeyA(GlbPropertiesWindowHandleP,msg->Code,msg->Qualifier,NULL))
  2052.             {
  2053.                 switch (msg->Code)
  2054.                 {
  2055.                     case 0x1b: // ESC
  2056.                         closeproperties();
  2057.                         GlbOpenPropertiesF = FALSE;
  2058.                         msg = NULL;
  2059.                         break;
  2060.                 }
  2061.             }
  2062.             break;
  2063.         case IDCMP_CLOSEWINDOW:
  2064.             closeproperties();
  2065.             GlbOpenPropertiesF = FALSE;
  2066.             msg = NULL;
  2067.             break;
  2068.     }
  2069.     if (msg)
  2070.         ReplyMsg(&msg->ExecMessage);
  2071.     return retval;
  2072. }
  2073.  
  2074. // *************************************************************
  2075. // ***
  2076. // *** NAME      handleintuimsg
  2077. // *** FUNCTION  handle all IDCMP messages
  2078. // ***
  2079. // *************************************************************
  2080. BOOL handleintuimsg(struct IntuiMessage *msg)
  2081. {
  2082.     BOOL retval = FALSE;
  2083.     if (msg->IDCMPWindow == GlbManagerWindowP)
  2084.         retval = handlemanagerwindow(msg);
  2085.     else if (msg->IDCMPWindow == GlbPropertiesWindowP)
  2086.         retval = handlepropertieswindow(msg);
  2087.     else // close gadget pressed?
  2088.     {
  2089.         struct ScreenNode *node;
  2090.         for (node = (struct ScreenNode *) ScreenList.mlh_Head;
  2091.             node->Node.Node.mln_Succ;
  2092.             node = (struct ScreenNode *) node->Node.Node.mln_Succ)
  2093.         {
  2094.             if (msg->IDCMPWindow == node->CloseGadget)
  2095.             {
  2096.                 switch (msg->Class)
  2097.                 {
  2098.                     case IDCMP_CLOSEWINDOW:
  2099.                         ReplyMsg(&msg->ExecMessage);
  2100.                         closescreen(node);
  2101.                         setselected();
  2102.                         msg = NULL;
  2103.                         break;
  2104.                 }
  2105.                 if (msg)
  2106.                     ReplyMsg(&msg->ExecMessage);
  2107.                 break;
  2108.             }
  2109.         }
  2110.     }
  2111.     return retval;
  2112. }
  2113.  
  2114. // *************************************************************
  2115. // ***
  2116. // *** NAME      readtok
  2117. // *** FUNCTION  read next token from a REXX command string
  2118. // ***
  2119. // *************************************************************
  2120. STRPTR readtok(STRPTR *cmdbuf)
  2121. {
  2122.     STRPTR cmd = *cmdbuf;
  2123.     while (isspace(*cmd))
  2124.         cmd++;
  2125.     if (!*cmd)
  2126.     {
  2127.         *cmdbuf = cmd;
  2128.         return NULL;
  2129.     }
  2130.     STRPTR command = cmd;
  2131.     UBYTE delim = '\0';
  2132.     UBYTE ch = *cmd;
  2133.     if (*cmd == '\"' || *cmd == '\'')
  2134.     {
  2135.         delim = ch;
  2136.         cmd++;
  2137.         for (;;)
  2138.         {
  2139.             while (*cmd && *cmd != delim)
  2140.                 cmd++;
  2141.             if (!*cmd)
  2142.             {
  2143.                 *cmdbuf = cmd;
  2144.                 return command; // last token must not stop with delim
  2145.             }
  2146.             if (*(cmd+1) != delim)
  2147.                 break;
  2148.             cmd += 2;
  2149.         }
  2150.     }
  2151.     else
  2152.     {
  2153.         while (*cmd && !isspace(*cmd))
  2154.             cmd++;
  2155.         if (!*cmd)
  2156.         {
  2157.             *cmdbuf = cmd;
  2158.             return command;
  2159.         }
  2160.     }
  2161.     *cmd++ = '\0';
  2162.     *cmdbuf = cmd;
  2163.     return command;
  2164. }
  2165.  
  2166. // *************************************************************
  2167. // ***
  2168. // *** NAME      handlerexxmsg
  2169. // *** FUNCTION  handle REXX messages
  2170. // ***
  2171. // *************************************************************
  2172. BOOL handlerexxmsg(struct RexxMsg *msg)
  2173. {
  2174.     BOOL retval = FALSE;
  2175.     if ((msg->rm_Action & RXCODEMASK) == RXCOMM)
  2176.     {
  2177.         UBYTE cmdbuf[256];
  2178.         strncpy(cmdbuf,msg->rm_Args[0],255);
  2179.         cmdbuf[255] = '\0';
  2180.         STRPTR cmd = cmdbuf;
  2181.         STRPTR command = readtok(&cmd);
  2182.         if (Stricmp(command,"OPEN") == 0) // OPEN <screenname>
  2183.         {
  2184.             STRPTR name = readtok(&cmd);
  2185.             if (name)
  2186.             {
  2187.                 if (!readtok(&cmd))
  2188.                 {
  2189.                     struct ScreenNode *node = FindScreenNode(name);
  2190.                     if (node)
  2191.                     {
  2192.                         if (node->StormScreenF && !node->OpenF)
  2193.                         {
  2194.                             openscreen(node);
  2195.                             node->CloseSoonF = TRUE;
  2196.                             if (GlbManagerWindowHandleP)
  2197.                             {
  2198.                                 SetGadgetAttrs(GlbManagerGadgets[GAD_MAN_LIST_ID],NULL,NULL,
  2199.                                     WLISTVIEWA_List,NULL,
  2200.                                     TAG_END);
  2201.                             }
  2202.                             GetDefaultScreenNode();
  2203.                             if (GlbManagerWindowHandleP)
  2204.                             {
  2205.                                 SetGadgetAttrs(GlbManagerGadgets[GAD_MAN_LIST_ID],GlbManagerWindowP,NULL,
  2206.                                     WLISTVIEWA_List,&ScreenList,
  2207.                                     TAG_END);
  2208.                             }
  2209.                             setselected();
  2210.                         }
  2211.                         else
  2212.                             msg->rm_Result1 = RC_WARN;
  2213.                     }
  2214.                     else
  2215.                         msg->rm_Result1 = RC_ERROR;
  2216.                 }
  2217.                 else
  2218.                     msg->rm_Result1 = RC_ERROR;
  2219.             }
  2220.             else
  2221.                 msg->rm_Result1 = RC_ERROR;
  2222.         }
  2223.         else if (Stricmp(command,"CLOSE") == 0) // CLOSE <screenname>
  2224.         {
  2225.             STRPTR name = readtok(&cmd);
  2226.             if (name)
  2227.             {
  2228.                 if (!readtok(&cmd))
  2229.                 {
  2230.                     struct ScreenNode *node = FindScreenNode(name);
  2231.                     if (node)
  2232.                     {
  2233.                         if (node->StormScreenF && node->OpenF)
  2234.                         {
  2235.                             closescreen(node);
  2236.                             if (GlbManagerWindowHandleP)
  2237.                             {
  2238.                                 SetGadgetAttrs(GlbManagerGadgets[GAD_MAN_LIST_ID],NULL,NULL,
  2239.                                     WLISTVIEWA_List,NULL,
  2240.                                     TAG_END);
  2241.                             }
  2242.                             GetDefaultScreenNode();
  2243.                             if (GlbManagerWindowHandleP)
  2244.                             {
  2245.                                 SetGadgetAttrs(GlbManagerGadgets[GAD_MAN_LIST_ID],GlbManagerWindowP,NULL,
  2246.                                     WLISTVIEWA_List,&ScreenList,
  2247.                                     TAG_END);
  2248.                             }
  2249.                             setselected();
  2250.                         }
  2251.                         else
  2252.                             msg->rm_Result1 = RC_WARN;
  2253.                     }
  2254.                     else
  2255.                         msg->rm_Result1 = RC_ERROR;
  2256.                 }
  2257.                 else
  2258.                     msg->rm_Result1 = RC_ERROR;
  2259.             }
  2260.             else
  2261.                 msg->rm_Result1 = RC_ERROR;
  2262.         }
  2263.         else if (Stricmp(command,"SCREENTOFRONT") == 0) // SCREENTOFRONT <screenname>
  2264.         {
  2265.             STRPTR name = readtok(&cmd);
  2266.             if (name)
  2267.             {
  2268.                 if (!readtok(&cmd))
  2269.                 {
  2270.                     struct ScreenNode *node = FindScreenNode(name);
  2271.                     if (node)
  2272.                     {
  2273.                         if (node->StormScreenF && node->OpenF)
  2274.                             ScreenToFront(node->Screen);
  2275.                         else
  2276.                             msg->rm_Result1 = RC_WARN;
  2277.                     }
  2278.                     else
  2279.                         msg->rm_Result1 = RC_ERROR;
  2280.                 }
  2281.                 else
  2282.                     msg->rm_Result1 = RC_ERROR;
  2283.             }
  2284.             else
  2285.                 msg->rm_Result1 = RC_ERROR;
  2286.         }
  2287.         else if (Stricmp(command,"SCREENTOBACK") == 0) // SCREENTOBACK <screenname>
  2288.         {
  2289.             STRPTR name = readtok(&cmd);
  2290.             if (name)
  2291.             {
  2292.                 if (!readtok(&cmd))
  2293.                 {
  2294.                     struct ScreenNode *node = FindScreenNode(name);
  2295.                     if (node)
  2296.                     {
  2297.                         if (node->StormScreenF && node->OpenF)
  2298.                             ScreenToBack(node->Screen);
  2299.                         else
  2300.                             msg->rm_Result1 = RC_WARN;
  2301.                     }
  2302.                     else
  2303.                         msg->rm_Result1 = RC_ERROR;
  2304.                 }
  2305.                 else
  2306.                     msg->rm_Result1 = RC_ERROR;
  2307.             }
  2308.             else
  2309.                 msg->rm_Result1 = RC_ERROR;
  2310.         }
  2311.         else if (Stricmp(command,"SETDEFSCREEN") == 0) // SETDEFSCREEN <screenname>
  2312.         {
  2313.             STRPTR name = readtok(&cmd);
  2314.             if (name)
  2315.             {
  2316.                 if (!readtok(&cmd))
  2317.                 {
  2318.                     struct ScreenNode *node = FindScreenNode(name);
  2319.                     if (node)
  2320.                     {
  2321.                         SetDefaultScreenNode(node);
  2322.                         setselected();
  2323.                         if (DefaultScreenNodeP != node)
  2324.                             msg->rm_Result1 = RC_WARN;
  2325.                     }
  2326.                     else
  2327.                         msg->rm_Result1 = RC_ERROR;
  2328.                 }
  2329.                 else
  2330.                     msg->rm_Result1 = RC_ERROR;
  2331.             }
  2332.             else
  2333.                 msg->rm_Result1 = RC_ERROR;
  2334.         }
  2335.         else if (Stricmp(command,"SHANGHAI") == 0) // SHANGHAI ON/OFF
  2336.         {
  2337.             STRPTR value = readtok(&cmd);
  2338.             if (value)
  2339.             {
  2340.                 if (!readtok(&cmd))
  2341.                 {
  2342.                     if (Stricmp(value,"ON") == 0)
  2343.                         setshanghai(TRUE);
  2344.                     else if (Stricmp(value,"OFF") == 0)
  2345.                         setshanghai(FALSE);
  2346.                     else
  2347.                         msg->rm_Result1 = RC_ERROR;
  2348.                 }
  2349.                 else
  2350.                     msg->rm_Result1 = RC_ERROR;
  2351.             }
  2352.             else
  2353.                 msg->rm_Result1 = RC_ERROR;
  2354.         }
  2355.         else if (Stricmp(command,"AUTOPOPUP") == 0) // AUTOPOPUP ON/OFF
  2356.         {
  2357.             STRPTR value = readtok(&cmd);
  2358.             if (value)
  2359.             {
  2360.                 if (!readtok(&cmd))
  2361.                 {
  2362.                     if (Stricmp(value,"ON") == 0)
  2363.                         setautopopup(TRUE);
  2364.                     else if (Stricmp(value,"OFF") == 0)
  2365.                         setautopopup(FALSE);
  2366.                     else
  2367.                         msg->rm_Result1 = RC_ERROR;
  2368.                 }
  2369.                 else
  2370.                     msg->rm_Result1 = RC_ERROR;
  2371.             }
  2372.             else
  2373.                 msg->rm_Result1 = RC_ERROR;
  2374.         }
  2375.         else if (Stricmp(command,"GETLIST") == 0)
  2376.         {
  2377.             if (!readtok(&cmd))
  2378.             {
  2379.                 char *Buf = (char *) AllocVec(16384,0);
  2380.                 if (Buf)
  2381.                 {
  2382.                     char *buf = Buf;
  2383.                     struct ScreenNode *node;
  2384.                     for (node = (struct ScreenNode *) ScreenList.mlh_Head;
  2385.                         node->Node.Node.mln_Succ;
  2386.                         node = (struct ScreenNode *) node->Node.Node.mln_Succ)
  2387.                     {
  2388.                         buf += sprintf(buf,"\"%s\" ",node->Name);
  2389.                     }
  2390.                     if (!(msg->rm_Result2 = (LONG) CreateArgstring(Buf,buf-Buf)))
  2391.                         msg->rm_Result1 = RC_ERROR;
  2392.                     FreeVec(Buf);
  2393.                 }
  2394.                 else
  2395.                     msg->rm_Result1 = RC_ERROR;
  2396.             }
  2397.             else
  2398.                 msg->rm_Result1 = RC_ERROR;
  2399.         }
  2400.         else if (Stricmp(command,"HIDE") == 0) // HIDE
  2401.         {
  2402.             if (!readtok(&cmd))
  2403.                 hide();
  2404.             else
  2405.                 msg->rm_Result1 = RC_ERROR;
  2406.         }
  2407.         else if (Stricmp(command,"SHOW") == 0) // SHOW
  2408.         {
  2409.             if (!readtok(&cmd))
  2410.                 show();
  2411.             else
  2412.                 msg->rm_Result1 = RC_ERROR;
  2413.         }
  2414.         else if (Stricmp(command,"QUIT") == 0) // QUIT
  2415.         {
  2416.             if (!readtok(&cmd))
  2417.                 retval = TRUE;
  2418.             else
  2419.                 msg->rm_Result1 = RC_ERROR;
  2420.         }
  2421.         else
  2422.         {
  2423.             msg->rm_Result1 = RC_FATAL; // unknown command
  2424.         }
  2425.         ReplyMsg(&msg->rm_Node)
  2426.     }
  2427.     return retval;
  2428. }
  2429.  
  2430. // *************************************************************
  2431. // ***
  2432. // *** NAME      main
  2433. // *** FUNCTION
  2434. // ***
  2435. // *************************************************************
  2436. void main(int argc, char *argv[])
  2437. {
  2438.     NewList((struct List *) &ScreenList);
  2439.  
  2440.     // set the current directory
  2441.     if (argc == 0) // started from WB
  2442.     {
  2443.         GlbCurrentDir = CurrentDir(DupLock(((struct WBStartup *) argv)->sm_ArgList[0].wa_Lock));
  2444.         GlbProgramNameP = ((struct WBStartup *) argv)->sm_ArgList[0].wa_Name;
  2445.     }
  2446.     else
  2447.     {
  2448.         GlbCurrentDir = CurrentDir(Lock("PROGDIR:",SHARED_LOCK));
  2449.         GlbProgramNameP = argv[0];
  2450.     }
  2451.  
  2452.     // open locale catalog
  2453.     if (LocaleBase)
  2454.     {
  2455.         GlbCatalogP = OpenCatalog(NULL,"StormScreenManager.catalog",
  2456.             OC_Version,0,
  2457.             TAG_END);
  2458.     }
  2459.  
  2460.     // open user interface
  2461.     if (!(GlbSurfaceP = WZ_OpenSurface(NULL,WizardSurface,
  2462.         SFH_Catalog,GlbCatalogP,
  2463.         TAG_END)))
  2464.     {
  2465.         error(getlocalestr(MSG_UNABLE_TO_OPEN_WIZARD_FILE_ID,MSG_UNABLE_TO_OPEN_WIZARD_FILE_ID_STR));
  2466.     }
  2467.     if (!(GlbIDCMPortP = CreateMsgPort()))
  2468.     {
  2469.         error(getlocalestr(MSG_FATAL_ID,MSG_FATAL_ID_STR));
  2470.     }
  2471.  
  2472.     // allocate signal for public screens
  2473.     if ((GlbScreenSignal = AllocSignal(~0)) == ~0)
  2474.     {
  2475.         error(getlocalestr(MSG_FATAL_ID,MSG_FATAL_ID_STR));
  2476.     }
  2477.  
  2478.     // create REXX msg port
  2479.     if (!(GlbRexxPortP = CreateMsgPort()))
  2480.     {
  2481.         error(getlocalestr(MSG_FATAL_ID,MSG_FATAL_ID_STR));
  2482.     }
  2483.     Forbid();
  2484.     if (FindPort("StormScreenManager"))
  2485.     {
  2486.         Permit();
  2487.         DeleteMsgPort(GlbRexxPortP);
  2488.         GlbRexxPortP = NULL;
  2489.         error(getlocalestr(MSG_REXXPORT_IN_USE_ID,MSG_REXXPORT_IN_USE_ID_STR));
  2490.     }
  2491.     GlbRexxPortP->mp_Node.ln_Name = "StormScreenManager";
  2492.     AddPort(GlbRexxPortP);
  2493.     Permit();
  2494.  
  2495.     STRPTR err = Load(GlbProgramNameP);
  2496.     if (err)
  2497.         error(err);
  2498.  
  2499.     // initialize commodity
  2500.     if (!(GlbBrokerPortP = CreateMsgPort()))
  2501.         error(getlocalestr(MSG_FATAL_ID,MSG_FATAL_ID_STR));
  2502.     struct NewBroker newbroker =
  2503.     {
  2504.         NB_VERSION,
  2505.         "StormScreenManager",
  2506.         getlocalestr(MSG_BROKER_TITLE_ID,MSG_BROKER_TITLE_ID_STR),
  2507.         getlocalestr(MSG_BROKER_DESCRIP_ID,MSG_BROKER_DESCRIP_ID_STR),
  2508.         NBU_UNIQUE|NBU_NOTIFY,
  2509.         COF_SHOW_HIDE,
  2510.         GlbCXPriority,
  2511.         GlbBrokerPortP
  2512.     };
  2513.     LONG brokererr;
  2514.     if (!(GlbBrokerP = CxBroker(&newbroker,&brokererr)))
  2515.     {
  2516.         error(brokererr != CBERR_DUP ? getlocalestr(MSG_UNABLE_TO_INSTALL_COMMODITY_ID,MSG_UNABLE_TO_INSTALL_COMMODITY_ID_STR) : NULL);
  2517.     }
  2518.     if (GlbCXPopkeyF)
  2519.     {
  2520.         CxObj *filter, *sender, *translate;
  2521.         filter = CxFilter(GlbCXPopkey);
  2522.         sender = CxSender(GlbBrokerPortP,EVT_HOTKEY);
  2523.         translate = CxTranslate(NULL);
  2524.         AttachCxObj(GlbBrokerP,filter);
  2525.         AttachCxObj(filter,sender);
  2526.         AttachCxObj(filter,translate);
  2527.         if (CxObjError(GlbBrokerP) || CxObjError(filter))
  2528.             error(getlocalestr(MSG_FATAL_ID,MSG_FATAL_ID_STR));
  2529.     }
  2530.     ActivateCxObj(GlbBrokerP,1);
  2531.  
  2532.     // final stage: init header, open screens, init listview
  2533.     InitHeaderNode();
  2534.     ScanOpenPubScreens();
  2535.     struct ScreenNode *node;
  2536.     for (node = (struct ScreenNode *) ScreenList.mlh_Head;
  2537.         node->Node.Node.mln_Succ;
  2538.         node = (struct ScreenNode *) node->Node.Node.mln_Succ)
  2539.     {
  2540.         if (node->StormScreenF && node->OpenSoonF)
  2541.         {
  2542.             openscreen(node);
  2543.         }
  2544.     }
  2545.     if (DefaultScreenNodeP)
  2546.         SetDefaultScreenNode(DefaultScreenNodeP);
  2547.     GetDefaultScreenNode();
  2548.     setshanghai(GlbShanghaiF);
  2549.     setautopopup(GlbAutoPopupF);
  2550.  
  2551.     // popup user interface?
  2552.     if (GlbStartPopupF)
  2553.         show();
  2554.  
  2555.     // the main loop
  2556.     ULONG mask = (1L << GlbIDCMPortP->mp_SigBit)
  2557.         | (1L << GlbScreenSignal)
  2558.         | (1L << GlbBrokerPortP->mp_SigBit)
  2559.         | (1L << GlbRexxPortP->mp_SigBit)
  2560.         | SIGBREAKF_CTRL_C;
  2561.     BOOL exitloop = FALSE;
  2562.     GlbExitSoonF = FALSE;
  2563.     while (!exitloop)
  2564.     {
  2565.         ULONG signals = Wait(mask);
  2566.  
  2567.         // Ctrl-C
  2568.         if (signals & SIGBREAKF_CTRL_C)
  2569.             GlbExitSoonF = TRUE;
  2570.  
  2571.         // IDCMP messages
  2572.         struct IntuiMessage *msg;
  2573.         while (msg = (struct IntuiMessage *) GetMsg(GlbIDCMPortP))
  2574.         {
  2575.             if (handleintuimsg(msg))
  2576.             {
  2577.                 GlbExitSoonF = TRUE;
  2578.                 break;
  2579.             }
  2580.         }
  2581.  
  2582.         // screen signals are sent if the last window is closed
  2583.         if (signals & (1L << GlbScreenSignal))
  2584.         {
  2585.             struct ScreenNode *node;
  2586.             for (node = (struct ScreenNode *) ScreenList.mlh_Head;
  2587.                 node->Node.Node.mln_Succ;
  2588.                 node = (struct ScreenNode *) node->Node.Node.mln_Succ)
  2589.             {
  2590.                 if (node->CloseSoonF && node->OpenF)
  2591.                 {
  2592.                     if (CloseScreen(node->Screen))
  2593.                     {
  2594.                         node->CloseSoonF = FALSE;
  2595.                         node->OpenF = FALSE;
  2596.                         node->Screen = NULL;
  2597.                     }
  2598.                 }
  2599.             }
  2600.             setselected();
  2601.         }
  2602.  
  2603.         // commodity messages
  2604.         CxMsg *cxmsg;
  2605.         while (cxmsg = (CxMsg *) GetMsg(GlbBrokerPortP))
  2606.         {
  2607.             ULONG msgid = CxMsgID(cxmsg);
  2608.             ULONG msgtype = CxMsgType(cxmsg);
  2609.             ReplyMsg((struct Message *) cxmsg);
  2610.             switch (msgtype)
  2611.             {
  2612.                 case CXM_IEVENT:
  2613.                     switch (msgid)
  2614.                     {
  2615.                         case EVT_HOTKEY: // hotkey pressed
  2616.                             show();
  2617.                             break;
  2618.                     }
  2619.                     break;
  2620.                 case CXM_COMMAND:
  2621.                     switch (msgid)
  2622.                     {
  2623.                         case CXCMD_DISABLE:
  2624.                             GlbDisableF = TRUE;
  2625.                             ActivateCxObj(GlbBrokerP,0);
  2626.                             break;
  2627.                         case CXCMD_ENABLE:
  2628.                             GlbDisableF = FALSE;
  2629.                             ActivateCxObj(GlbBrokerP,1);
  2630.                             break;
  2631.                         case CXCMD_APPEAR:
  2632.                         case CXCMD_UNIQUE: // SSM is started second time
  2633.                             show();
  2634.                             break;
  2635.                         case CXCMD_DISAPPEAR:
  2636.                             hide();
  2637.                             break;
  2638.                         case CXCMD_KILL:
  2639.                             GlbExitSoonF = TRUE; // exit as soon as possible
  2640.                             break;
  2641.                     }
  2642.                     break;
  2643.             }
  2644.         }
  2645.  
  2646.         // handle REXX messages
  2647.         struct RexxMsg *rxmsg;
  2648.         while (rxmsg = (struct RexxMsg *) GetMsg(GlbRexxPortP))
  2649.         {
  2650.             if (handlerexxmsg(rxmsg))
  2651.             {
  2652.                 GlbExitSoonF = TRUE;
  2653.                 break;
  2654.             }
  2655.         }
  2656.  
  2657.         // try to exit
  2658.         if (GlbExitSoonF)
  2659.         {
  2660.             exitloop = TRUE;
  2661.             struct ScreenNode *node;
  2662.             for (node = (struct ScreenNode *) ScreenList.mlh_Head;
  2663.                 node->Node.Node.mln_Succ;
  2664.                 node = (struct ScreenNode *) node->Node.Node.mln_Succ)
  2665.             {
  2666.                 if (node->StormScreenF && node->OpenF)
  2667.                 {
  2668.                     // try to close the screen
  2669.                     closescreen(node);
  2670.                     if (node->OpenF) // couldn't close the screen
  2671.                         exitloop = FALSE; // -> cannot exit
  2672.                 }
  2673.             }
  2674.             setselected(); // some screens may be closed
  2675.         }
  2676.     }
  2677.     error(NULL); // exit gracefully
  2678. }
  2679.